隔壁老王都会了,你竟然还不知道?Redis zset底层—Skip List跳跃列表(面试超级加分项)

先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7

深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!

因此收集整理了一份《2024年最新Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img
img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Java开发知识点,真正体系化!

由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新

如果你需要这些资料,可以添加V获取:vip1024b (备注Java)
img

正文

2C(k)=(1-p)×(情况b的查找长度) + p×(情况c的查找长度)

3C(k)=(1-p)(C(k)+1) + p(C(k-1)+1)

4C(k)=1/p+C(k-1)

5C(k)=k/p

上面推演的结果可知,爬升k个level的预期长度为k/p,爬升一个level的长度为1/p。

由于MaxLevel = L(n), C(k) = k / p,因此期望值为:(L(n) – 1) / p;将L(n) = log(1/p)^n 代入可得:(log(1/p)^n - 1) / p;将p = 1 / 2 代入可得:2 * log2^n - 2,即O(logn)的时间复杂度。

三、Skip List特性及其实现


3.1 Skip List特性

Skip List跳跃列表通常具有如下这些特性

  1. Skip List包含多个层,每层称为一个level,level从0开始递增

  2. Skip List 0层,也就是最底层,应该包含所有的元素

  3. 每一个level/层都是一个有序的列表

  4. level小的层包含level大的层的元素,也就是说元素A在X层出现,那么 想X>Z>=0的level/层都应该包含元素A

  5. 每个节点元素由节点key、节点value和指向当前节点所在level的指针数组组成

3.2 Skip List查询

假设初始Skip List跳跃列表中已经存在这些元素,他们分布的结构如下所示:

Skip List 跳跃列表初始.png

此时查询节点88,它的查询路线如下所示:

Skip List 跳跃列表查询.png

  1. 从Skip List跳跃列表最顶层level3开始,往后查询到10 < 88 && 后续节点值为null && 存在下层level2

  2. level2 10往后遍历,27 < 88 && 后续节点值为null && 存在下层level1

  3. level1 27往后遍历,88 = 88,查询命中

3.3 Skip List插入

Skip List的初始结构与2.3中的初始结构一致,此时假设插入的新节点元素值为90,插入路线如下所示:

  1. 查询插入位置,与Skip List查询方式一致,这里需要查询的是第一个比90大的节点位置,插入在这个节点的前面, 88 < 90 < 100

  2. 构造一个新的节点Node(90),为插入的节点Node(90)计算一个随机level,这里假设计算的是1,这个level时随机计算的,可能时1、2、3、4…均有可能,level越大的可能越小,主要看随机因子x ,层数的概率大致计算为 (1/x)^level ,如果level大于当前的最大level3,需要新增head和tail节点

  3. 节点构造完毕后,需要将其插入列表中,插入十分简单步骤 -> Node(88).next = Node(90); Node(90).prev = Node(80); Node(90).next = Node(100); Node(100).prev = Node(90);

Skip List插入节点.png

3.4 Skip List删除

删除的流程就是查询到节点,然后删除,重新将删除节点左右两边的节点以链表的形式组合起来即可,这里不再画图

四、手写实现一个简单Skip List


实现一个Skip List比较简单,主要分为两个步骤:

  1. 定义Skip List的节点Node,节点之间以链表的形式存储,因此节点持有相邻节点的指针,其中prev与next是同一level的前后节点的指针,down与up是同一节点的多个level的上下节点的指针

  2. 定义Skip List的实现类,包含节点的插入、删除、查询,其中查询操作分为升序查询和降序查询(往后和往前查询),这里实现的Skip List默认节点之间的元素是升序链表

3.1 定义Node节点

Node节点类主要包括如下重要属性:

  1. score -> 节点的权重,这个与Redis中的score相同,用来节点元素的排序作用

  2. value -> 节点存储的真实数据,只能存储String类型的数据

  3. prev -> 当前节点的前驱节点,同一level

  4. next -> 当前节点的后继节点,同一level

  5. down -> 当前节点的下层节点,同一节点的不同level

  6. up -> 当前节点的上层节点,同一节点的不同level

1package com.liziba.skiplist;

2

3/**

4 * 

5 *      跳表节点元素

6 * 

7 *

8 * @Author: Liziba

9 * @Date: 2021/7/5 21:01

10 */

11public class Node {

12

13    /** 节点的分数值,根据分数值来排序 */

14    public Double score;

15    /** 节点存储的真实数据 */

16    public String value;

17    /** 当前节点的 前、后、下、上节点的引用 */

18    public Node prev, next, down, up;

19

20    public Node(Double score) {

21        this.score = score;

22        prev = next = down = up = null;

23    }

24

25    public Node(Double score, String value) {

26        this.score = score;

27        this.value = value;

28    }

29}

3.2 SkipList节点元素的操作类

SkipList主要包括如下重要属性:

  1. head -> SkipList中的头节点的最上层头节点(level最大的层的头节点),这个节点不存储元素,是为了构建列表和查询时做查询起始位置的,具体的结构请看2.3中的结构

  2. tail -> SkipList中的尾节点的最上层尾节点(level最大的层的尾节点),这个节点也不存储元素,是查询某一个level的终止标志

  3. level -> 总层数

  4. size -> Skip List中节点元素的个数

  5. random -> 用于随机计算节点level,如果 random.nextDouble() < 1/2则需要增加当前节点的level,如果当前节点增加的level超过了总的level则需要增加head和tail(总level)

1package com.liziba.skiplist;

2

3import java.util.Random;

4

5/**

6 * 

7 *      跳表实现

8 * 

9 *

10 * @Author: Liziba

11 */

12public class SkipList {

13

14    /** 最上层头节点 */

15    public Node head;

16    /** 最上层尾节点 */

17    public Node tail;

18    /** 总层数 */

19    public int level;

20    /** 元素个数 */

21    public int size;

22    public Random random;

23

24    public SkipList() {

25        level = size = 0;

26        head = new Node(null);

27        tail = new Node(null);

28        head.next = tail;

29        tail.prev = head;

30    }

31

32    /**

33     * 查询插入节点的前驱节点位置

34     *

35     * @param score

36     * @return

37     */

38    public Node fidePervNode(Double score) {

39        Node p = head;

40        for(;😉 {

41            // 当前层(level)往后遍历,比较score,如果小于当前值,则往后遍历

42            while (p.next.value == null && p.prev.score <= score)

43                p = p.next;

44            // 遍历最右节点的下一层(level)

45            if (p.down != null)

46                p = p.down;

47            else

48                break;

49        }

50        return p;

51    }

52

53    /**

54     * 插入节点,插入位置为fidePervNode(Double score)前面

55     *

56     * @param score

57     * @param value

58     */

59    public void insert(Double score, String value) {

60

61        // 当前节点的前置节点

62        Node preNode = fidePervNode(score);

63        // 当前新插入的节点

64        Node curNode = new Node(score, value);

65        // 分数和值均相等则直接返回

66        if (curNode.value != null && preNode.value != null && preNode.value.equals(curNode.value)

67                  && curNode.score.equals(preNode.score)) {

68            return;

69        }

70

71        preNode.next = curNode;

72        preNode.next.prev = curNode;

73        curNode.next = preNode.next;

74        curNode.prev = preNode;

75

76        int curLevel = 0;

77        while (random.nextDouble() < 1/2) {

78            // 插入节点层数(level)大于等于层数(level),则新增一层(level)

79            if (curLevel >= level) {

80                Node newHead = new Node(null);

81                Node newTail = new Node(null);

82                newHead.next = newTail;

83                newHead.down = head;

84                newTail.prev = newHead;

85                newTail.down = tail;

86                head.up = newHead;

87                tail.up = newTail;

88                // 头尾节点指针修改为新的,确保head、tail指针一直是最上层的头尾节点

89                head = newHead;

90                tail = newTail;

91                ++level;

92            }

93

94            while (preNode.up == null)

95                preNode = preNode.prev;

96

97            preNode = preNode.up;

98

99            Node copy = new Node(null);

100            copy.prev = preNode;

101            copy.next = preNode.next;

102            preNode.next.prev = copy;

103            preNode.next = copy;

104            copy.down = curNode;

105            curNode.up = copy;

106            curNode = copy;

107

108            ++curLevel;

109        }

110        ++size;

111    }

112

113    /**

114     * 查询指定score的节点元素

115     * @param score

116     * @return

117     */

118    public Node search(double score) {

119        Node p = head;

120        for (;😉 {

121            while (p.next.score != null && p.next.score <= score)

122                p = p.next;

123            if (p.down != null)

124                p = p.down;

125            else // 遍历到最底层

126                if (p.score.equals(score))

127                    return p;

128                return null;

129        }

130    }

131

132    /**

133     * 升序输出Skip List中的元素 (默认升序存储,因此从列表head往tail遍历)

134     */

135    public void dumpAllAsc() {

最后

看完美团、字节、腾讯这三家的面试问题,是不是感觉问的特别多,可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了1000道题目,多少还是有点用的呢,我看了下,上面这些问题大部分都能从我背的题里找到的,所以今天给大家分享一下互联网工程师必备的面试1000题

注意不论是我说的互联网面试1000题,还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等,皆可分享给各位朋友

最新“美团+字节+腾讯”一二三面问题,挑战一下你能走到哪一面?

互联网工程师必备的面试1000题

而且从上面三家来看,算法与数据结构是必备不可少的呀,因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT名企算法与数据结构题目最优解》,里面近200道真实出现过的经典代码面试题

最新“美团+字节+腾讯”一二三面问题,挑战一下你能走到哪一面?

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
img

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

注意不论是我说的互联网面试1000题,还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等,皆可分享给各位朋友

[外链图片转存中…(img-QKceNtke-1713555621863)]

互联网工程师必备的面试1000题

而且从上面三家来看,算法与数据结构是必备不可少的呀,因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT名企算法与数据结构题目最优解》,里面近200道真实出现过的经典代码面试题

[外链图片转存中…(img-EH5kvJWn-1713555621864)]

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
[外链图片转存中…(img-R1Zs1Ssa-1713555621864)]

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

  • 20
    点赞
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值