数据结构与算法分析：（十）跳表(1)

我们知道，在单链表中，一旦定位好要插入的位置，插入节点的时间复杂度是很低的，就是 O(1)。但是，这里为了保证原始链表中数据的有序性，我们需要先找到要插入的位置，这个查找操作就会比较耗时。

对于纯粹的单链表，需要遍历每个结点，来找到插入的位置。但是，对于跳表来说，我们讲过查找某个节点的的时间复杂度是 O(logn)，所以这里查找某个数据应该插入的位置，方法也是类似的，时间复杂度也是 O(logn)。

我们再来看删除操作。

如果这个节点在索引中也有出现，我们除了要删除原始链表中的节点，还要删除索引中的。因为单链表中的删除操作需要拿到要删除节点的前驱节点，然后通过指针操作完成删除。所以在查找要删除的节点的时候，一定要获取前驱节点。当然，如果我们用的是双向链表，就不需要考虑这个问题了。

五、跳表的代码实现

---

/**

• 跳表代码实现

• 跳表中存储的是正整数，并且存储的是不重复的。

*/

public class SkipList {

private static final int MAX_LEVEL = 16;

private int levelCount = 1;

// 带头链表

private Node head = new Node(MAX_LEVEL);

private Random random = new Random();

public Node find(int value) {

Node cur = head;

// 从最大层开始查找，找到前一节点，通过–i，移动到下层再开始查找

for (int i = levelCount - 1; i >= 0; i–) {

while (cur.forwards[i] != null && cur.forwards[i].data < value) {

// 找到前一节点

cur = cur.forwards[i];

}

}

if (cur.forwards[0] != null && cur.forwards[0].data == value) {

return cur.forwards[0];

} else {

return null;

}

}

/**

• 优化插入版本

• @param value

*/

public void insert(int value) {

int level = head.forwards[0] == null ? 1 : randomLevel();

// 每次只增加一层，如果条件满足

if (level > levelCount) {

level = ++levelCount;

}

Node newNode = new Node(level);

newNode.data = value;

Node cur = head;

// 从最大层开始查找，找到前一节点，通过–i，移动到下层再开始查找

for (int i = levelCount - 1; i >= 0; --i) {

while (cur.forwards[i] != null && cur.forwards[i].data < value) {

// 找到前一节点

cur = cur.forwards[i];

}

// levelCount 会 > level，所以加上判断

if (level > i) {

if (cur.forwards[i] == null) {

cur.forwards[i] = newNode;

} else {

Node next = cur.forwards[i];

cur.forwards[i] = newNode;

newNode.forwards[i] = next;

}

}

}

}

public void delete(int value) {

Node[] update = new Node[levelCount];

Node cur = head;

for (int i = levelCount - 1; i >= 0; --i) {

while (cur.forwards[i] != null && cur.forwards[i].data < value) {

cur = cur.forwards[i];

}

update[i] = cur;

}

if (cur.forwards[0] != null && cur.forwards[0].data == value) {

for (int i = levelCount - 1; i >= 0; --i) {

if (update[i].forwards[i] != null && update[i].forwards[i].data == value) {

update[i].forwards[i] = update[i].forwards[i].forwards[i];

}

}

}

}

/**

• 随机 level 次，如果是奇数层数 +1，防止伪随机

*/

private int randomLevel() {

int level = 1;

for (int i = 1; i < MAX_LEVEL; ++i) {

if (random.nextInt() % 2 == 1) {

level++;

}

}

return level;

}

/**

• 打印每个节点数据和最大层数

*/

public void printAll() {

Node cur = head;

while (cur.forwards[0] != null) {

System.out.print(cur.forwards[0] + " ");

cur = cur.forwards[0];

}

System.out.println();

}

/**

• 打印所有数据

*/

public void printAll_beautiful() {

Node p = head;

Node[] c = p.forwards;

Node[] d = c;

int maxLevel = c.length;

for (int i = maxLevel - 1; i >= 0; i–) {

do {

System.out.print((d[i] != null ? d[i].data : null) + “:” + i + “-------”);

} while (d[i] != null && (d = d[i].forwards)[i] != null);

System.out.println();

d = c;

}

}

/**

• 跳表的节点，每个节点记录了当前节点数据和所在层数数据

*/

public class Node {

private int data = -1;

/**

• 表示当前节点位置的下一个节点所有层的数据，从上层切换到下层，就是数组下标-1，

• forwards[3]表示当前节点在第三层的下一个节点。

*/

private Node forwards[];

/**

• 这个值其实可以不用，看优化insert()

*/

private int maxLevel = 0;

public Node(int level) {

forwards = new Node[level];

}

@Override

public String toString() {

StringBuilder builder = new StringBuilder();

builder.append("{ data: ");

builder.append(data);

builder.append("; levels: ");

builder.append(maxLevel);

builder.append(" }");

return builder.toString();

}

}

public static void main(String[] args) {

SkipList list = new SkipList();

list.insert(1);

list.insert(2);

list.insert(6);

list.insert(7);

list.insert(8);

list.insert(3);

list.insert(4);

list.insert(5);

System.out.println();

list.printAll_beautiful();

}

}

输出结果：

null:15-------

null:14-------

null:13-------

null:12-------

null:11-------

null:10-------

null:9-------

null:8-------

null:7-------

null:6-------

null:5-------

3:4-------

3:3-------4:3-------5:3-------7:3-------

3:2-------4:2-------5:2-------6:2-------7:2-------8:2-------

2:1-------3:1-------4:1-------5:1-------6:1-------7:1-------8:1-------

1:0-------2:0-------3:0-------4:0-------5:0-------6:0-------7:0-------8:0-------

Spring全套教学资料

Spring是Java程序员的《葵花宝典》，其中提供的各种大招，能简化我们的开发，大大提升开发效率！目前99%的公司使用了Spring，大家可以去各大招聘网站看一下，Spring算是必备技能，所以一定要掌握。

目录：

部分内容：

Spring源码

• 第一部分 Spring 概述
• 第二部分 核心思想
• 第三部分 手写实现 IoC 和 AOP（自定义Spring框架）
• 第四部分 Spring IOC 高级应用
  基础特性
  高级特性
• 第五部分 Spring IOC源码深度剖析
  设计优雅
  设计模式
  注意：原则、方法和技巧
• 第六部分 Spring AOP 应用
  声明事务控制
• 第七部分 Spring AOP源码深度剖析
  必要的笔记、必要的图、通俗易懂的语言化解知识难点

脚手框架：SpringBoot技术

它的目标是简化Spring应用和服务的创建、开发与部署，简化了配置文件，使用嵌入式web服务器，含有诸多开箱即用的微服务功能，可以和spring cloud联合部署。

Spring Boot的核心思想是约定大于配置，应用只需要很少的配置即可，简化了应用开发模式。

• SpringBoot入门
• 配置文件
• 日志
• Web开发
• Docker
• SpringBoot与数据访问
• 启动配置原理
• 自定义starter

微服务架构：Spring Cloud Alibaba

同 Spring Cloud 一样，Spring Cloud Alibaba 也是一套微服务解决方案，包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。

• 微服务架构介绍
• Spring Cloud Alibaba介绍
• 微服务环境搭建
• 服务治理
• 服务容错
• 服务网关
• 链路追踪
• ZipKin集成及数据持久化
• 消息驱动
• 短信服务
• Nacos Confifig—服务配置
• Seata—分布式事务
• Dubbo—rpc通信

Spring MVC

目录：

部分内容：

a介绍

• 微服务环境搭建
• 服务治理
• 服务容错
• 服务网关
• 链路追踪
• ZipKin集成及数据持久化
• 消息驱动
• 短信服务
• Nacos Confifig—服务配置
• Seata—分布式事务
• Dubbo—rpc通信

[外链图片转存中…(img-kFazvM17-1721190399732)]

[外链图片转存中…(img-n95rvMdl-1721190399732)]

Spring MVC

目录：

[外链图片转存中…(img-qf1kCN56-1721190399733)]

[外链图片转存中…(img-sCtKkzJF-1721190399733)]

[外链图片转存中…(img-pNC7CPUl-1721190399734)]

部分内容：

[外链图片转存中…(img-aH2OieHb-1721190399734)]

[外链图片转存中…(img-yJT8LmT5-1721190399735)]