• 跳跃表
    • 实现

    跳跃表

    跳跃列表是一种数据结构。它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是 O(log n) ，优于普通队列的 O(n)。

    快速查询是通过维护一个多层次的链表，且每一层链表中的元素是前一层链表元素的子集。一开始时，算法在最稀疏的层次进行搜索，直至需要查找的元素在该层两个相邻的元素中间。这时，算法将跳转到下一个层次，重复刚才的搜索，直到找到需要查找的元素为止。跳过的元素的方法可以是 随机性选择 或 确定性选择，其中前者更为常见。

    跳跃表 - 图1

    在查找目标元素时，从顶层列表、头元素起步。算法沿着每层链表搜索，直至找到一个大于或等于目标的元素，或者到达当前层列表末尾。如果该元素等于目标元素，则表明该元素已被找到；如果该元素大于目标元素或已到达链表末尾，则退回到当前层的上一个元素，然后转入下一层进行搜索。

    跳跃列表不像平衡树等数据结构那样提供对最坏情况的性能保证：由于用来建造跳跃列表采用随机选取元素进入更高层的方法，在小概率情况下会生成一个不平衡的跳跃列表（最坏情况例如最底层仅有一个元素进入了更高层，此时跳跃列表的查找与普通列表一致）。但是在实际中它通常工作良好，随机化平衡方案也比平衡二叉查找树等数据结构中使用的确定性平衡方案容易实现。跳跃列表在并行计算中也很有用：插入可以在跳跃列表不同的部分并行地进行，而不用对数据结构进行全局的重新平衡。

    跳跃表插入一个元素：

    跳跃表 - 图2

    实现

    因为跳跃列表中的元素可以在多个列表中，所以每个元素可以有多于一个指针。跳跃列表的插入和删除的实现与普通的链表操作类似，但高层元素必须在进行多个链表中进行插入或删除。

    1. package io.github.hadyang.leetcode.algo;
    3. import lombok.Getter;
    4. import lombok.Setter;
    6. import java.util.Arrays;
    7. import java.util.Random;
    9. /**
    10.  * @author haoyang.shi
    11.  */
    12. public class SkipList<K extends Comparable<K>, V> {
    14.     @Getter
    15.     @Setter
    16.     static final class Node<K extends Comparable<K>, V> {
    17.         private K key;
    19.         private V value;
    21.         private Node<K, V> up, down, pre, next;
    23.         Node(K key, V value) {
    24.             this.key = key;
    25.             this.value = value;
    26.         }
    29.         @Override
    30.         public String toString() {
    31.             return "Node{" +
    32.                     "key=" + key +
    33.                     ", value=" + value +
    34.                     ", hashcode=" + hashCode() +
    35.                     ", up=" + (up == null ? "null" : up.hashCode()) +
    36.                     ", down=" + (down == null ? "null" : down.hashCode()) +
    37.                     ", pre=" + (pre == null ? "null" : pre.hashCode()) +
    38.                     ", next=" + (next == null ? "null" : next.hashCode()) +
    39.                     '}';
    40.         }
    41.     }
    43.     private Node<K, V> head;//k,v都是NULL
    45.     private Integer levels = 0;
    47.     private Integer length = 0;
    49.     private Random random = new Random(System.currentTimeMillis());
    51.     public SkipList() {
    52.         createNewLevel();
    53.     }
    55.     public void put(K key, V value) {
    56.         if (key == null || value == null) {
    57.             return;
    58.         }
    60.         Node<K, V> newNode = new Node<>(key, value);
    61.         insertNode(newNode);
    62.     }
    64.     private void insertNode(Node<K, V> newNode) {
    65.         Node<K, V> curNode = findNode(newNode.getKey());
    66.         if (curNode.getKey() == null) {
    67.             insertNext(curNode, newNode);
    68.         } else if (curNode.getKey().compareTo(newNode.getKey()) == 0) {
    69.             //update
    70.             curNode.setValue(newNode.getValue());
    71.             return;
    72.         } else {
    73.             insertNext(curNode, newNode);
    74.         }
    76.         int currentLevel = 1;
    77.         Node<K, V> oldTop = newNode;
    78.         while (random.nextInt(100) < 50) {
    79.             Node<K, V> newTop = new Node<>(newNode.getKey(), null);
    81.             if (currentLevel >= levels) {
    82.                 createNewLevel();
    83.             }
    85.             while (curNode.getPre() != null && curNode.getUp() == null) {
    86.                 curNode = curNode.getPre();
    87.             }
    89.             if (curNode.getUp() == null) {
    90.                 continue;
    91.             }
    93.             curNode = curNode.getUp();
    94.             Node<K, V> curNodeNext = curNode.getNext();
    96.             curNode.setNext(newTop);
    97.             newTop.setPre(curNode);
    98.             newTop.setDown(oldTop);
    99.             oldTop.setUp(newTop);
    101.             newTop.setNext(curNodeNext);
    102.             oldTop = newTop;
    104.             currentLevel++;
    105.         }
    106.     }
    108.     private void createNewLevel() {
    109.         Node<K, V> newHead = new Node<>(null, null);
    110.         if (this.head == null) {
    111.             this.head = newHead;
    112.             this.levels++;
    113.             return;
    114.         }
    116.         this.head.setUp(newHead);
    117.         newHead.setDown(this.head);
    118.         this.head = newHead;
    119.         this.levels++;
    120.     }
    122.     private void insertNext(Node<K, V> curNode, Node<K, V> newNode) {
    123.         Node<K, V> curNodeNext = curNode.getNext();
    124.         newNode.setNext(curNodeNext);
    125.         if (curNodeNext != null) {
    126.             curNodeNext.setPre(newNode);
    127.         }
    128.         curNode.setNext(newNode);
    129.         newNode.setPre(curNode);
    131.         this.length++;
    132.     }
    134.     public V get(K key) {
    135.         Node<K, V> node = findNode(key);
    136.         if (key.equals(node.getKey())) {
    137.             return node.getValue();
    138.         }
    140.         return null;
    141.     }
    143.     private Node<K, V> findNode(K key) {
    144.         Node<K, V> curNode = this.head;
    146.         for (; ; ) {
    147.             while (curNode.getNext() != null && curNode.getNext().getKey().compareTo(key) <= 0) {
    148.                 curNode = curNode.getNext();
    149.             }
    151.             if (curNode.getDown() != null) {
    152.                 curNode = curNode.getDown();
    153.             } else {
    154.                 break;
    155.             }
    156.         }
    158.         return curNode;
    159.     }
    161.     public void print() {
    162.         Node<K, V> curI = this.head;
    164.         String[][] strings = new String[levels][length + 1];
    165.         for (String[] string : strings) {
    166.             Arrays.fill(string, "0");
    167.         }
    169.         while (curI.getDown() != null) {
    170.             curI = curI.getDown();
    171.         }
    173.         System.out.println("levels:" + levels + "_" + "length:" + length);
    175.         int i = 0;
    176.         while (curI != null) {
    177.             Node<K, V> curJ = curI;
    179.             int j = levels - 1;
    180.             while (curJ != null) {
    181.                 strings[j][i] = String.valueOf(curJ.getKey());
    183.                 if (curJ.getUp() == null) {
    184.                     break;
    185.                 }
    186.                 curJ = curJ.getUp();
    187.                 j--;
    188.             }
    190.             if (curI.getNext() == null) {
    191.                 break;
    192.             }
    193.             curI = curI.getNext();
    194.             i++;
    195.         }
    197.         for (String[] string : strings) {
    198.             System.out.println(Arrays.toString(string));
    199.         }
    200.     }
    202.     public static void main(String[] args) {
    204.         SkipList<Integer, String> skipList = new SkipList<>();
    206.         skipList.put(2, "B");
    207.         skipList.put(1, "A");
    208.         skipList.put(3, "C");
    210.         skipList.print();
    212.         System.out.println(skipList.get(2));
    214.     }
    216. }