跳表的实现

跳表是一种查找效率可以和红黑树媲美的算法，而且实现简单，适合需要范围查找的场景。

跳表是在链表的基础上实现的结构，主要思想是同过建立多层索引的方法来提高查找效率。

跳表的实现精髓是通过多级索引指针，因此数据域有一个存储数据的节点和一个索引指针数组，如下：

class Node(object):
    def __init__(self, data: int, level: int):
        self.data = data
        self.forward = [None]*level

插入操作和基本的链表插入类似，差别在于，确定需要建立几级索引，并将数据插入到合适的位置，为了索引结构的平衡性，此处引入来一个随机函数来确定索引层级。

    def Random(self):
        level = 1
        while True:
            if random.randint(0, self.max_level) % 2 == 0:
                level += 1
            else:
                break
        if level > self.max_level:
            level = self.max_level
        return level

插入操作分3步进行：

1、找到插入位置，为了插入方便，在查找工程中记录下各层数据插入的位置。

2、确定索引层级

3、插入数据

    def Insert(self, data: int):
        update_arr = [None]*self.max_level

        #查找插入位置
        index = self.cur_level - 1
        p = self.head
        while index >= 0:
            q = p.forward[index]
            while q and q.key < data:
                p = q
                q = p.forward[index]
            update_arr[index] = p
            index -= 1

        #确定索引层级
        k = self.Random()
        if k > self.cur_level:
            index = self.cur_level
            while index < k:
                update_arr[index] = self.head
                index += 1
            self.cur_level = k

        #插入数据
        node = Node(data, k)
        i = 0
        while i < k:
            node.forward[i] = update_arr[i].forward[i]
            update_arr[i].forward[i] = node
            i += 1
        return True

删除操作比较简单，直接在各层找到节点删除

    def Delete(self, data: int):
        level = self.cur_level - 1

        p = self.head
        while level >= 0:
            q = p.forward[level]
            while q and q.key <= data:
                if q.key == data:
                    p.forward[level] = q.forward[level]
                    break
                p = q
                q = q.forward[level]
            level -= 1

整体程序如下：

class Node(object):
    def __init__(self, data: int, level: int):
        self.key = data
        self.forward = [None]*level

class SkipList(object):
    def __init__(self, max_level: int):
        self.max_level = max_level
        self.head = Node(0, max_level)
        self.cur_level = 0

    def Random(self):
        level = 1
        while True:
            if random.randint(0, self.max_level) % 2 == 0:
                level += 1
            else:
                break
        if level > self.max_level:
            level = self.max_level
        return level

    def Insert(self, data: int):
        update_arr = [None]*self.max_level

        #查找插入位置
        index = self.cur_level - 1
        p = self.head
        while index >= 0:
            q = p.forward[index]
            while q and q.key < data:
                p = q
                q = p.forward[index]
            update_arr[index] = p
            index -= 1

        #确定索引层级
        k = self.Random()
        if k > self.cur_level:
            index = self.cur_level
            while index < k:
                update_arr[index] = self.head
                index += 1
            self.cur_level = k

        #插入数据
        node = Node(data, k)
        i = 0
        while i < k:
            node.forward[i] = update_arr[i].forward[i]
            update_arr[i].forward[i] = node
            i += 1
        return True

    def Show(self):
        for i in range(self.max_level):
            cur = self.head.forward[i]
            print("header: ", end="")
            while cur:
                print(cur.key, end=" : ")
                cur = cur.forward[i]
            print()

    def Search(self, data: int):
        level = self.cur_level - 1
        p = self.head
        q = p.forward[level]
        while level >= 0:
            while q and q.key < data:
                p = q
                q = p.forward[level]
            level -= 1

        if p == None:
            return False
        else:
            cur_node = p.forward[0]
            while cur_node and cur_node != q:
                if cur_node and cur_node.key == data:
                    return True
                cur_node = cur_node.forward[0]
        return False

    def Delete(self, data: int):
        level = self.cur_level - 1

        p = self.head
        while level >= 0:
            q = p.forward[level]
            while q and q.key <= data:
                if q.key == data:
                    p.forward[level] = q.forward[level]
                    break
                p = q
                q = q.forward[level]
            level -= 1