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()
}
2.png

有用的話,動動小手,點個贊。

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。