go 实现跳表

原文地址：https://mp.weixin.qq.com/s/9IJRJcRz5WiCUqxScYkVrQ

背景：

相信大家都知道排行榜，在很多场景里都需要用到排行榜功能，尤其是游戏中！之前在了解排行榜实现机制的时候，在网上看得最多的答复便是使用redis的有序集合实现。于是深入了解了一下redis中的有序集合。

redis中的有序结合(sorted set)是一种线性结构，底层是用有序链表实现的，但是对链表增加的“索引”，并且对索引进行了分层，跳表每层散落的节点数不同，查找过程中通过索引向下层跳转，最终落到最下层的数据链中，这样做的目的是通过空间换时间来获取更高的效率，故称之为跳跃表（跳表）。

1，跳表简介

跳表是由William Pugh发明的，这位确实是个大牛，搞出一些很不错的东西。简单说来跳表也是

链表的一种，只不过它在链表的基础上增加了跳跃功能，正是这个跳跃的功能，使得在查找元素时，跳表能够提供O(log n)的时间复杂

度。红黑树等这样的平衡数据结构查找的时间复杂度也是O(log n)，并且相对于红黑树这样的平衡二叉树skiplist的优点是更好的支持并

发操作，但是要实现像红黑树这样的数据结构并非易事,但是只要你熟悉链表的基本操作,再加之对跳表原理的理解，实现一个跳表数据

结构就是一个很自然的事情了。

此外，跳表在当前热门的开源项目中也有很多应用，比如LevelDB的核心数据结构memtable是用跳表实现的，redis的sorted set数据

结构也是有跳表实现的。

2，skiplist主要思想

先从链表开始，如果是一个简单的链表（不一定有序），那么我们在链表中查找一个元素X的话，需要将遍历整个链表直到找到元素X为止。

有序数组查找问题我们可以使用二分查找算法，但对于有序链表却不能使用二分查找。这个时候我们在想下平衡树,比如BST,他们都是通过把一些

节点取出来作为其节点下某种意义的索引，比如父节点一般大于左子节点而小于右子节点。因此这个时候我们想到类似二叉搜索树的做法把一些

节点提取出来，作为索引。

当然我们还可以再从一级索引提取一些元素出来，作为二级索引,这样更能加快元素搜索。

这基本上就是跳表的核心思想，其实是一种通过“空间来换取时间”的一个算法，通过在每个节点中增加了向前的指针(即层)，从而提升查找的效率。

跳跃列表是按层建造的。底层是一个普通的有序链表。每个更高层都充当下面列表的「快速跑道」，这里在层 i 中的元素按某个固定的概率 p (通常

为0.5或0.25)出现在层 i+1 中。平均起来，每个元素都在 1/(1-p) 个列表中出现, 而最高层的元素（通常是在跳跃列表前端的一个特殊的头元素）

在 O(log1/p n) 个列表中出现。

3，SkipList基本数据结构及其实现

一个跳表，应该具有以下特征：

1>,一个跳表应该有几个层（level）组成；

2>,跳表的第一层包含所有的元素；

3>,每一层都是一个有序的链表；

4>,如果元素x出现在第i层，则所有比i小的层都包含x；

5>,每个节点包含key及其对应的value和一个指向同一层链表的下个节点的指针数组

4，注意问题

1>,如果放任增长，高度失去控制会影响效果，所以一般会限制最高高度

2>,如果删除的值在索引中，注意要删除每一层

5.代码实现

https://github.com/pyihe/go-skipList

package main

import (
	"fmt"
	"math/rand"
	"time"
)

const MAX_LEVEL=10
type Skiplist struct {
	maxLevel int
	root []*Node
}
type Node struct{
	level int
	next []*Node
	prev []*Node
	value int
	count int
}

func NewNode(level,value int)*Node{
	return &Node{
		level:level,
		value:value,
		next:make([]*Node,level+1),
		prev:make([]*Node,level+1),
		count:1,
	}
}

func Constructor() Skiplist {
	return Skiplist{
		maxLevel:-1,
	}
}

func (this *Skiplist) SearchPos(target int)*Node{
	if this.maxLevel==-1{
		return nil
	}
	next:=this.root[this.maxLevel]
	for level:=next.level;level>=0;level--{
		if target==next.value{
			return next
		}else if target<next.value{
			for next.prev[level]!=nil && target<=next.prev[level].value{
				next=next.prev[level]
			}
		}else{
			for next.next[level]!=nil && target>=next.next[level].value{
				next=next.next[level]
			}
		}
		fmt.Println("search :",target," level",level)
	}
	return next
}

func (this *Skiplist) Search(target int) bool {
	n:=this.SearchPos(target)
	this.Print()
	if n==nil{
		return false
	}
	return n.value==target
}
func(this *Skiplist)Print(){
	if this.root==nil{
		return
	}
	fmt.Println(*this)
	for i:=this.maxLevel;i>=0;i--{
		cur:=this.root[i]
		for cur!=nil && cur.next!=nil{
			fmt.Print("->[",cur.value,cur.count,"]")
			cur=cur.next[i]
		}
		fmt.Println(i)
	}
}

func(this*Skiplist)randomUpgrade()bool{
	rand.Seed(time.Now().UnixNano())
	r:=rand.Intn(7)%2
	if this.maxLevel>MAX_LEVEL{
		return false
	}
	fmt.Println("rand:---",r)
	return r==1
}

func(n*Node)InsertLevelNode(level int,nn *Node){
	if n==nil ||n.prev==nil || n.next==nil || nn==nil ||nn.prev==nil ||nn.next==nil{
		return
	}
	if n.value>nn.value {
		prev:=n.prev[level]

		n.prev[level]=nn
		nn.next[level]=n

		nn.prev[level]=prev

		if prev!=nil{
			prev.next[level]=nn
		}
	}else{
		next:=n.next[level]

		n.next[level]=nn
		nn.prev[level]=n

		nn.next[level]=next
		if next!=nil{
			next.prev[level]=nn
		}
	}
}

func (this *Skiplist) Add(num int)  {
	this.Print()
	n:=this.SearchPos(num)
	if n==nil{
		this.maxLevel=0
		n=NewNode(0,num)
		this.root=append(this.root,n)
		return
	}

	if n.value==num{
		n.count++
		return
	}


	if this.randomUpgrade(){
		this.maxLevel++
		nn:=NewNode(this.maxLevel,num)
		this.root=append(this.root,nn)

		for i:=1;i<=this.maxLevel-1;i++{
			in:=this.root[i]
			for in!=nil && in.value>num  && in.prev!=nil && in.prev[i]!=nil{
				in=in.prev[i]
			}
			for in!=nil && in.value<num && in.next!=nil && in.next[i]!=nil{
				in=in.next[i]
			}
			in.InsertLevelNode(i,nn)
		}

		n.InsertLevelNode(0,nn)
	}else{
		nn:=NewNode(0,num)
		n.InsertLevelNode(0,nn)
	}
}

func (this*Skiplist)DeleteNode(n*Node,level int){
	if n==nil{
		return
	}
	next:=n.next[level]
	prev:=n.prev[level]
	//fmt.Println("next",next,"prev",prev)
	if prev!=nil{
		prev.next[level]=next
	}else{
		this.root[level]=next
	}
	if next!=nil{
		next.prev[level]=prev
	}
}

func (this *Skiplist) Erase(num int) bool {
	//this.Print()
	n:=this.SearchPos(num)
	if n!=nil{
		//fmt.Println("erease ",*n)
	}
	if n==nil || n.value!=num{
		return false
	}

	if n.count>1{
		n.count--
		return true
	}

	for i:=0;i<=n.level;i++{
		//fmt.Println("-->",i)
		this.DeleteNode(n,i)
	}
	//fmt.Println("-->")
	//this.Print()
	//level i 删除了，i+1 肯定删除了，特殊情况，n层都是最高index，
	count:=0
	for level:=this.maxLevel;n.level==this.maxLevel && level>=0 && this.root!=nil && this.root[level]==nil ;level--{
		count++
	}
	this.root=this.root[:len(this.root)-count]
	this.maxLevel-=count

	n.count--
	n.level=-1
	n.next=nil
	n.prev=nil
	n=nil

	return true
}


/**
 * Your Skiplist object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Search(target);
 * obj.Add(num);
 * param_3 := obj.Erase(num);
 */

func main() {
	obj := Constructor();
	obj.Add(0);
	obj.Add(1);
	obj.Add(4);
	obj.Add(1);
	param_1 := obj.Search(1);
	fmt.Println(param_1)
	param_3 := obj.Erase(1);
	fmt.Println(param_3)
}