一文详解跳表的原理及实现

r囧r小猫 2024-03-25 23:09 14阅读 0赞

### 前言 ###

跳表可以达到和红黑树一样的时间复杂度**O(logN)**，且实现简单，**Redis**中的有序集合对象的底层数据结构就使用了跳表。本篇文章将对跳表的实现进行学习。

### 正文 ###

#### 一. 跳表的基础概念 ####

跳表，即跳跃表（**Skip List**），是基于并联的链表数据结构，操作效率可以达到**O(logN)**，对并发友好。跳表的示意图如下所示。

![format_png][]

跳表的特点，可以概括如下。

*  跳表是多层（**level**）链表结构；
 *  跳表中的每一层都是一个有序链表，并且按照元素升序（默认）排列；
 *  跳表中的元素会在哪一层出现是随机决定的，但是只要元素出现在了第**k**层，那么**k**层以下的链表也会出现这个元素；
 *  跳表的底层的链表包含所有元素；
 *  跳表头节点和尾节点不存储元素，且头节点和尾节点的层数就是跳表的最大层数；
 *  跳表中的节点包含两个指针，一个指针指向同层链表的后一节点，一个指针指向下层链表的同元素节点。

以上图中的跳表为例，如果要查找元素71，那么查找流程如下图所示。

![format_png 1][]

从顶层链表的头节点开始查找，查找到元素71的节点时，一共遍历了4个节点，但是如果按照传统链表的方式（即从跳表的底层链表的头节点开始向后查找），那么就需要遍历7个节点，所以跳表以空间换时间，缩短了操作跳表所需要花费的时间。

#### 二. 跳表的节点 ####

已知跳表中的节点，需要有指向当前层链表后一节点的指针，和指向下层链表的同元素节点的指针，所以跳表中的节点，定义如下。

public class SkiplistNode {
    
        public int data;
        public SkiplistNode next;
        public SkiplistNode down;
        public int level;
    
        public SkiplistNode(int data, int level) {
            this.data = data;
            this.level = level;
        }
    
    }
    复制代码

上述是跳表中的节点的最简单的定义方式，存储的元素**data**为整数，节点之间进行比较时直接比较元素**data**的大小。

#### 三. 跳表的初始化 ####

跳表初始化时，将每一层链表的头尾节点创建出来并使用集合将头尾节点进行存储，头尾节点的层数随机指定，且头尾节点的层数就代表当前跳表的层数。初始化后，跳表结构如下所示。

![format_png 2][]

跳表初始化的相关代码如下所示。

public LinkedList<SkiplistNode> headNodes;
    public LinkedList<SkiplistNode> tailNodes;
    
    public int curLevel;
    
    public Random random;
    
    public Skiplist() {
        random = new Random();
    
        // headNodes用于存储每一层的头节点
        headNodes = new LinkedList<>();
        // tailNodes用于存储每一层的尾节点
        tailNodes = new LinkedList<>();
    
        // 初始化跳表时，跳表的层数随机指定
        curLevel = getRandomLevel();
        // 指定了跳表的初始的随机层数后，就需要将每一层的头节点和尾节点创建出来并构建好关系
        SkiplistNode head = new SkiplistNode(Integer.MIN_VALUE, 0);
        SkiplistNode tail = new SkiplistNode(Integer.MAX_VALUE, 0);
        for (int i = 0; i <= curLevel; i++) {
            head.next = tail;
            headNodes.addFirst(head);
            tailNodes.addFirst(tail);
    
            SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
            SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
            headNew.down = head;
            tailNew.down = tail;
    
            head = headNew;
            tail = tailNew;
        }
    }
    复制代码

#### 四. 跳表的添加方法 ####

每一个元素添加到跳表中时，首先需要随机指定这个元素在跳表中的层数，如果随机指定的层数大于了跳表的层数，则在将元素添加到跳表中之前，还需要扩大跳表的层数，而扩大跳表的层数就是将头尾节点的层数扩大。下面给出需要扩大跳表层数的一次添加的过程。

初始状态时，跳表的层数为2，如下图所示。

![format_png 3][]

现在要往跳表中添加元素120，并且随机指定的层数为3，大于了当前跳表的层数2，此时需要先扩大跳表的层数，如下图所示。

![format_png 4][]

将元素120插入到跳表中时，从顶层开始，逐层向下插入，如下图所示。

![format_png 5][]

跳表的添加方法的代码如下所示。

public void add(int num) {
        // 获取本次添加的值的层数
        int level = getRandomLevel();
        // 如果本次添加的值的层数大于当前跳表的层数
        // 则需要在添加当前值前先将跳表层数扩充
        if (level > curLevel) {
            expanLevel(level - curLevel);
        }
    
        // curNode表示num值在当前层对应的节点
        SkiplistNode curNode = new SkiplistNode(num, level);
        // preNode表示curNode在当前层的前一个节点
        SkiplistNode preNode = headNodes.get(curLevel - level);
        for (int i = 0; i <= level; i++) {
            // 从当前层的head节点开始向后遍历，直到找到一个preNode
            // 使得preNode.data < num <= preNode.next.data
            while (preNode.next.data < num) {
                preNode = preNode.next;
            }
    
            // 将curNode插入到preNode和preNode.next中间
            curNode.next = preNode.next;
            preNode.next = curNode;
    
            // 如果当前并不是0层，则继续向下层添加节点
            if (curNode.level > 0) {
                SkiplistNode downNode = new SkiplistNode(num, curNode.level - 1);
                // curNode指向下一层的节点
                curNode.down = downNode;
                // curNode向下移动一层
                curNode = downNode;
            }
            // preNode向下移动一层
            preNode = preNode.down;
        }
    }
    
    private void expanLevel(int expanCount) {
        SkiplistNode head = headNodes.getFirst();
        SkiplistNode tail = tailNodes.getFirst();
        for (int i = 0; i < expanCount; i++) {
            SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
            SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
            headNew.down = head;
            tailNew.down = tail;
    
            head = headNew;
            tail = tailNew;
    
            headNodes.addFirst(head);
            tailNodes.addFirst(tail);
        }
    }
    复制代码

#### 五. 跳表的搜索方法 ####

在跳表中搜索一个元素时，需要从顶层开始，逐层向下搜索。搜索时遵循如下规则。

*  目标值大于当前节点的后一节点值时，继续在本层链表上向后搜索；
 *  目标值大于当前节点值，小于当前节点的后一节点值时，向下移动一层，从下层链表的同节点位置向后搜索；
 *  目标值等于当前节点值，搜索结束。

下图是一个搜索过程的示意图。

![format_png 6][]

跳表的搜索的代码如下所示。

public boolean search(int target) {
        // 从顶层开始寻找，curNode表示当前遍历到的节点
        SkiplistNode curNode = headNodes.getFirst();
        while (curNode != null) {
            if (curNode.next.data == target) {
                // 找到了目标值对应的节点，此时返回true
                return true;
            } else if (curNode.next.data > target) {
                // curNode的后一节点值大于target
                // 说明目标节点在curNode和curNode.next之间
                // 此时需要向下层寻找
                curNode = curNode.down;
            } else {
                // curNode的后一节点值小于target
                // 说明目标节点在curNode的后一节点的后面
                // 此时在本层继续向后寻找
                curNode = curNode.next;
            }
        }
        return false;
    }
    复制代码

#### 六. 跳表的删除方法 ####

当在跳表中需要删除某一个元素时，则需要将这个元素在所有层的节点都删除，具体的删除规则如下所示。

*  首先按照跳表的搜索的方式，搜索待删除节点，如果能够搜索到，此时搜索到的待删除节点位于该节点层数的最高层；
 *  从待删除节点的最高层往下，将每一层的待删除节点都删除掉，删除方式就是让待删除节点的前一节点直接指向待删除节点的后一节点。

下图是一个删除过程的示意图。

![format_png 7][]

跳表的删除的代码如下所示。

public boolean erase(int num) {
        // 删除节点的遍历过程与寻找节点的遍历过程是相同的
        // 不过在删除节点时如果找到目标节点，则需要执行节点删除的操作
        SkiplistNode curNode = headNodes.getFirst();
        while (curNode != null) {
            if (curNode.next.data == num) {
                // preDeleteNode表示待删除节点的前一节点
                SkiplistNode preDeleteNode = curNode;
                while (true) {
                    // 删除当前层的待删除节点，就是让待删除节点的前一节点指向待删除节点的后一节点
                    preDeleteNode.next = curNode.next.next;
                    // 当前层删除完后，需要继续删除下一层的待删除节点
                    // 这里让preDeleteNode向下移动一层
                    // 向下移动一层后，preDeleteNode就不一定是待删除节点的前一节点了
                    preDeleteNode = preDeleteNode.down;
    
                    // 如果preDeleteNode为null，说明已经将底层的待删除节点删除了
                    // 此时就结束删除流程，并返回true
                    if (preDeleteNode == null) {
                        return true;
                    }
    
                    // preDeleteNode向下移动一层后，需要继续从当前位置向后遍历
                    // 直到找到一个preDeleteNode，使得preDeleteNode.next的值等于目标值
                    // 此时preDeleteNode就又变成了待删除节点的前一节点
                    while (preDeleteNode.next.data != num) {
                        preDeleteNode = preDeleteNode.next;
                    }
                }
            } else if (curNode.next.data > num) {
                curNode = curNode.down;
            } else {
                curNode = curNode.next;
            }
        }
        return false;
    }
    复制代码

#### 七. 跳表完整代码 ####

跳表完整代码如下所示。

public class Skiplist {
    
        public LinkedList<SkiplistNode> headNodes;
        public LinkedList<SkiplistNode> tailNodes;
    
        public int curLevel;
    
        public Random random;
    
        public Skiplist() {
            random = new Random();
    
            // headNodes用于存储每一层的头节点
            headNodes = new LinkedList<>();
            // tailNodes用于存储每一层的尾节点
            tailNodes = new LinkedList<>();
    
            // 初始化跳表时，跳表的层数随机指定
            curLevel = getRandomLevel();
            // 指定了跳表的初始的随机层数后，就需要将每一层的头节点和尾节点创建出来并构建好关系
            SkiplistNode head = new SkiplistNode(Integer.MIN_VALUE, 0);
            SkiplistNode tail = new SkiplistNode(Integer.MAX_VALUE, 0);
            for (int i = 0; i <= curLevel; i++) {
                head.next = tail;
                headNodes.addFirst(head);
                tailNodes.addFirst(tail);
    
                SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
                SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
                headNew.down = head;
                tailNew.down = tail;
    
                head = headNew;
                tail = tailNew;
            }
        }
    
        public boolean search(int target) {
            // 从顶层开始寻找，curNode表示当前遍历到的节点
            SkiplistNode curNode = headNodes.getFirst();
            while (curNode != null) {
                if (curNode.next.data == target) {
                    // 找到了目标值对应的节点，此时返回true
                    return true;
                } else if (curNode.next.data > target) {
                    // curNode的后一节点值大于target
                    // 说明目标节点在curNode和curNode.next之间
                    // 此时需要向下层寻找
                    curNode = curNode.down;
                } else {
                    // curNode的后一节点值小于target
                    // 说明目标节点在curNode的后一节点的后面
                    // 此时在本层继续向后寻找
                    curNode = curNode.next;
                }
            }
            return false;
        }
    
        public void add(int num) {
            // 获取本次添加的值的层数
            int level = getRandomLevel();
            // 如果本次添加的值的层数大于当前跳表的层数
            // 则需要在添加当前值前先将跳表层数扩充
            if (level > curLevel) {
                expanLevel(level - curLevel);
            }
    
            // curNode表示num值在当前层对应的节点
            SkiplistNode curNode = new SkiplistNode(num, level);
            // preNode表示curNode在当前层的前一个节点
            SkiplistNode preNode = headNodes.get(curLevel - level);
            for (int i = 0; i <= level; i++) {
                // 从当前层的head节点开始向后遍历，直到找到一个preNode
                // 使得preNode.data < num <= preNode.next.data
                while (preNode.next.data < num) {
                    preNode = preNode.next;
                }
    
                // 将curNode插入到preNode和preNode.next中间
                curNode.next = preNode.next;
                preNode.next = curNode;
    
                // 如果当前并不是0层，则继续向下层添加节点
                if (curNode.level > 0) {
                    SkiplistNode downNode = new SkiplistNode(num, curNode.level - 1);
                    // curNode指向下一层的节点
                    curNode.down = downNode;
                    // curNode向下移动一层
                    curNode = downNode;
                }
                // preNode向下移动一层
                preNode = preNode.down;
            }
        }
    
        public boolean erase(int num) {
            // 删除节点的遍历过程与寻找节点的遍历过程是相同的
            // 不过在删除节点时如果找到目标节点，则需要执行节点删除的操作
            SkiplistNode curNode = headNodes.getFirst();
            while (curNode != null) {
                if (curNode.next.data == num) {
                    // preDeleteNode表示待删除节点的前一节点
                    SkiplistNode preDeleteNode = curNode;
                    while (true) {
                        // 删除当前层的待删除节点，就是让待删除节点的前一节点指向待删除节点的后一节点
                        preDeleteNode.next = curNode.next.next;
                        // 当前层删除完后，需要继续删除下一层的待删除节点
                        // 这里让preDeleteNode向下移动一层
                        // 向下移动一层后，preDeleteNode就不一定是待删除节点的前一节点了
                        preDeleteNode = preDeleteNode.down;
    
                        // 如果preDeleteNode为null，说明已经将底层的待删除节点删除了
                        // 此时就结束删除流程，并返回true
                        if (preDeleteNode == null) {
                            return true;
                        }
    
                        // preDeleteNode向下移动一层后，需要继续从当前位置向后遍历
                        // 直到找到一个preDeleteNode，使得preDeleteNode.next的值等于目标值
                        // 此时preDeleteNode就又变成了待删除节点的前一节点
                        while (preDeleteNode.next.data != num) {
                            preDeleteNode = preDeleteNode.next;
                        }
                    }
                } else if (curNode.next.data > num) {
                    curNode = curNode.down;
                } else {
                    curNode = curNode.next;
                }
            }
            return false;
        }
    
        private void expanLevel(int expanCount) {
            SkiplistNode head = headNodes.getFirst();
            SkiplistNode tail = tailNodes.getFirst();
            for (int i = 0; i < expanCount; i++) {
                SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
                SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
                headNew.down = head;
                tailNew.down = tail;
    
                head = headNew;
                tail = tailNew;
    
                headNodes.addFirst(head);
                tailNodes.addFirst(tail);
            }
        }
    
        private int getRandomLevel() {
            int level = 0;
            while (random.nextInt(2) > 1) {
                level++;
            }
            return level;
        }
    
    }
    复制代码

### 总结 ###

跳表的时间复杂度与**AVL**树和红黑树相同，可以达到**O(logN)**，但是**AVL**树要维持高度的平衡，红黑树要维持高度的近似平衡，这都会导致插入或者删除节点时的一些时间开销，所以跳表相较于**AVL**树和红黑树来说，省去了维持高度的平衡的时间开销，但是相应的也付出了更多的空间来存储多个层的节点，所以跳表是用空间换时间的数据结构。

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dbace07ac96c414797fc5ff6c1916375.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/463b502361224cb39409a310e3860e98.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/11cd67f6607842f483c40ffd9d0a3a9f.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/de718e47e1684537b12c5d1ce0705ca2.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bddde491def242439afc945f05440874.png
[format_png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2830a32a8abe45889d15603696b0fe97.png
[format_png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9e5d592ba1f94a63ba5e4a0e31bbe79c.png
[format_png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/046101d0c49b46a4ad71b85af49d12c6.png