golang skiplist(跳錶)實現
前言
首先來了解一下跳錶的概念，跳錶中的表指的是連結串列，所以巨集觀上來看跳錶是一種連結串列結構，那麼它與傳統的連結串列有什麼不同呢？一般的單鏈表如果我們需要查詢第n個元素，那麼就需要從頭節點開始一個一個的遍歷n次，時間複雜讀就是O(n)，而跳錶就是在單鏈表之上做了一些優化，使時間複雜度達到O(logn)。
在O(logn)複雜度內查詢元素，我們不難想到其他的資料結構，avl樹，紅黑樹，b樹，b+樹之類。但是這些樹狀結構有個共性就是需要在元素數量發生變化的時候保持平衡才能繼續維持效能，所以就需要做一個額外的操作，旋轉。而旋轉一方面增加了程式碼實現的複雜性，同時也降低了在頻繁做增刪操作時，樹的效能。
而跳錶則是一種程式碼實現簡單，效率相近的資料結構。既然跳錶這麼好，那麼接下來看一下跳錶在單鏈表的基礎上做了什麼優化？
跳錶
1.png
跳錶的結構如上圖所示，可以看到跳錶是分層的連結串列，底層是真正儲存的資料，傳統的單鏈表，而之上的層可以理解為下層節點的索引。所以這也是典型的空間換時間的優化方式。那麼有人要問了，當插入節點的時候，什麼時候分層呢？相隔幾個節點的時候分層呢？這的確是一個很難的問題，我也不知道到底什麼時候分層好，幾個節點分層好？計算機可能也不知道。但是問題總得解決，其實當插入一個節點的時候，這時候不就是分層與不分層兩個選擇嗎？那就“拋硬幣”吧。
是的，跳錶也覺得拋硬幣是個好辦法，簡單有效。一般會設定一個概率值（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()
}
