前言
首先來了解一下跳表的概念，跳表中的表指的是鏈表，所以宏觀上來看跳表是一種鏈表結構，那么它與傳統的鏈表有什么不同呢？一般的單鏈表如果我們需要查找第n個元素，那么就需要從頭節點開始一個一個的遍歷n次，時間復雜讀就是O(n)，而跳表就是在單鏈表之上做了一些優化，使時間復雜度達到O(logn)。
在O(logn)復雜度內查找元素，我們不難想到其他的數據結構，avl樹，紅黑樹，b樹，b+樹之類。但是這些樹狀結構有個共性就是需要在元素數量發生變化的時候保持平衡才能繼續維持性能，所以就需要做一個額外的操作，旋轉。而旋轉一方面增加了代碼實現的復雜性，同時也降低了在頻繁做增刪操作時，樹的性能。
而跳表則是一種代碼實現簡單，效率相近的數據結構。既然跳表這么好，那么接下來看一下跳表在單鏈表的基礎上做了什么優化？
跳表
跳表的結構如上圖所示，可以看到跳表是分層的鏈表，底層是真正保存的數據，傳統的單鏈表，而之上的層可以理解為下層節點的索引。所以這也是典型的空間換時間的優化方式。那么有人要問了，當插入節點的時候，什么時候分層呢？相隔幾個節點的時候分層呢？這的確是一個很難的問題，我也不知道到底什么時候分層好，幾個節點分層好？計算機可能也不知道。但是問題總得解決，其實當插入一個節點的時候，這時候不就是分層與不分層兩個選擇嗎？那就“拋硬幣”吧。
是的，跳表也覺得拋硬幣是個好辦法，簡單有效。一般會設置一個概率值（0.5），滿足概率就加層，不滿足就什么都不做，另外跳表每一層的元素都是有序的。
so ，跳表 = 鏈表 + 有序 + 概率分層
接下來，簡單描述一下跳表做增刪查的流程：
ps:head 節點為左上第一個節點，tail 節點為右上第一個節點
Get：如上圖，如果要查找12這個元素，那么就從head節點開始，如果下一個節點比12小繼續在當前層向后移動，如果下一個節點比12大或者nil，那么就向下移動，從它的下一層開始查找，以此類推最終會落到底層，直到找到12.
Insert：插入15，首先找到離15最近，比15小的節點12，然后將節點插入底層（單鏈表的插入操作）。判斷是否需要分層，不需要返回。需要的話自底向上一層一層插入節點
Remove：同樣的刪除15，首先找到離15最近，比15小的節點12，然后將節點在底層刪除，如果有上層節點，繼續刪除。
talk is cheap，show you the code：
package skipList
import (
"fmt"
"math"
"math/rand"
"time"
)
const UP_LEVELS_ABILITY = 500
const UP_LEVELS_TOTAL = 1000
type skipListNode struct {
score int64
val interface{}
next *skipListNode
pre *skipListNode
up *skipListNode
down *skipListNode
}
type skipList struct {
head *skipListNode
tail *skipListNode
size int
levels int
}
func NewSkipList() *skipList {
sl := new(skipList)
sl.head = new(skipListNode)
sl.tail = new(skipListNode)
sl.head.score = math.MinInt64
sl.tail.score = math.MaxInt64
sl.head.next = sl.tail
sl.tail.pre = sl.head
sl.size = 0
sl.levels = 1
return sl
}
func (sl *skipList) Size() int {
return sl.size
}
func (sl *skipList) Levels() int {
return sl.levels
}
func (sl *skipList) Get(score int64) interface{} {
node := sl.findNode(score)
if node.score == score {
return node.val
} else {
return nil
}
}
func (sl *skipList) Insert(score int64, val interface{}) {
f := sl.findNode(score)
if f.score == score {
f.val = val
return
}
curNode := new(skipListNode)
curNode.score = score
curNode.val = val
sl.insertAfter(f, curNode)
rander := rand.New(rand.NewSource(time.Now().UnixNano()))
curlevels := 1
for rander.Intn(UP_LEVELS_TOTAL) < UP_LEVELS_ABILITY {
curlevels++
if curlevels > sl.levels {
sl.newlevels()
}
for f.up == nil {
f = f.pre
}
f = f.up
tmpNode := &skipListNode{score: score}
curNode.up = tmpNode
tmpNode.down = curNode
sl.insertAfter(f, tmpNode)
curNode = tmpNode
}
sl.size++
}
func (sl *skipList) Remove(score int64) interface{} {
f := sl.findNode(score)
if f.score != score {
return nil
}
v := f.val
for f != nil {
f.pre.next = f.next
f.next.pre = f.pre
f = f.up
}
return v
}
func (sl *skipList) newlevels() {
nhead := &skipListNode{score: math.MinInt64}
ntail := &skipListNode{score: math.MaxInt64}
nhead.next = ntail
ntail.pre = nhead
sl.head.up = nhead
nhead.down = sl.head
sl.tail.up = ntail
ntail.down = sl.tail
sl.head = nhead
sl.tail = ntail
sl.levels++
}
func (sl *skipList) insertAfter(pNode *skipListNode, curNode *skipListNode) {
curNode.next = pNode.next
curNode.pre = pNode
pNode.next.pre = curNode
pNode.next = curNode
}
func (sl *skipList) findNode(score int64) *skipListNode {
p := sl.head
for p != nil {
if p.score == score {
if p.down == nil {
return p
}
p = p.down
} else if p.score < score {
if p.next.score > score {
if p.down == nil {
return p
}
p = p.down
} else {
p = p.next
}
}
}
return p
}
func (sl *skipList) Print() {
mapScore := make(map[int64]int)
p := sl.head
for p.down != nil {
p = p.down
}
index := 0
for p != nil {
mapScore[p.score] = index
p = p.next
index++
}
p = sl.head
for i := 0; i < sl.levels; i++ {
q := p
preIndex := 0
for q != nil {
s := q.score
if s == math.MinInt64 {
fmt.Printf("%s", "BEGIN")
q = q.next
continue
}
index := mapScore[s]
c := (index - preIndex - 1) * 6
for m := 0; m < c; m++ {
fmt.Print("-")
}
if s == math.MaxInt64 {
fmt.Printf("-->%s\n", "END")
} else {
fmt.Printf("-->%3d", s)
preIndex = index
}
q = q.next
}
p = p.down
}
}
最后的print加了一個打印，方便更直觀的觀察這個結構，效果如下：
package main
import (
"skipList"
)
func main() {
sk := skipList.NewSkipList()
sk.Insert(100, "lala")
sk.Insert(11, "sx")
sk.Insert(22, "11")
sk.Insert(3, "dd")
sk.Insert(80, "bb")
sk.Insert(77, "bb")
sk.Insert(6, "bb")
sk.Insert(88, "bb")
sk.Insert(33, "bb")
sk.Insert(44, "bb")
//fmt.Println(sk.Get(22))
//fmt.Println(sk.Get(55))
//fmt.Println(sk.Remove(22))
//fmt.Println(sk.Get(22))
//fmt.Println(sk.Size())
//fmt.Println(sk.Layout())
sk.Print()
}
有用的話，動動小手，點個贊。
