从零开始学习数据结构—【链表】—【探索环形链的设计之美】

news2025/3/13 8:55:25

环形链表

文章目录

  • 环形链表
    • 1.结构图
    • 2.具体实现
      • 2.1.环形链表结构
      • 2.2.头部添加数据
        • 2.2.1.具体实现
        • 2.2.2.测试添加数据
      • 2.3.尾部添加数据
        • 2.3.1.具体实现
        • 2.3.2.添加测试数据
      • 2.4.删除头部数据
        • 2.4.1.具体实现
        • 2.4.2.测试删除数据
      • 2.5.删除尾部数据
        • 2.5.1.具体实现
        • 2.5.2.测试删除数据
      • 2.6.根据内容删除节点
        • 2.6.1.具体实现
      • 2.7.遍历环形链表
        • 2.7.1.迭代器遍历
        • 2.7.2.使用递归进行遍历
      • 2.7.3.测试
    • 3.具体应用场景
      • 3.1.优点
      • 3.2.缺点
      • 3.3.应用场景

1.结构图

双向环形链表带哨兵，这个时候的哨兵，可以当头，也可做尾

带哨兵双向循环链表：结构稍微复杂，实现简单。一般用来单独存储数据，实际中使用的链表数据结构都是带头双向链表。另外，这个结构虽然结构复杂，但是使用代码实现后会发现结构会带来很多优势。

双向环形链表是一种链式数据结构，其每个节点包含指向前一个节点和后一个节点的指针，形成了一个闭环。这意味着链表的尾部节点指向头部节点，而头部节点指向尾部节点，形成了一个环状的结构。

带哨兵的双向环形链表在头部和尾部都有一个特殊的哨兵节点，这个哨兵节点不存储任何数据，仅用于简化链表的操作。哨兵节点使得链表中始终存在一个不变的头部和尾部，即使链表为空也如此。具体而言：

  1. 头部哨兵节点： 位于链表的头部，它的前驱节点指向链表的尾部节点，而它的后继节点指向链表的第一个真实节点。头部哨兵节点使得在头部执行操作时变得更加简单，不需要特殊处理链表为空的情况，也不需要区分头部和尾部的操作。
  2. 尾部哨兵节点： 位于链表的尾部，它的后继节点指向链表的头部节点，而它的前驱节点指向链表的最后一个真实节点。尾部哨兵节点同样简化了尾部操作，使得在尾部进行插入、删除等操作更加方便。

带哨兵的双向环形链表在实现时通常会带来一些优势：

  • 简化操作： 哨兵节点的存在使得对链表头部和尾部的操作变得更加统一和简化。不需要特别处理头部或尾部为空的情况，使得代码更加清晰和简洁。
  • 增强鲁棒性： 哨兵节点可以避免出现空指针异常，因为链表中始终存在一个不变的头部和尾部。这增强了代码的鲁棒性和可靠性。
  • 逻辑统一： 哨兵节点的存在使得链表的逻辑更加统一，不需要在特殊情况下单独处理头部或尾部节点，使得代码更加一致性和可读性。

在这里插入图片描述

2.具体实现

2.1.环形链表结构

public class DoubleLinkedListSentinel {
	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

	public DoubleLinkedListSentinel(){
		// 初始化时 环形连链表创建指向自身
		sentinel.next = sentinel;
		sentinel.prev = sentinel;
	}

	/**
	 * 创建哨兵
	 */
	private Node sentinel = new Node(null,-1,null);

	private static class Node{
		Node prev;     // 头指针
		Integer value; // 值
		Node next;     // 尾指针

		public Node(Node prev, Integer value, Node next) {
			this.prev = prev;
			this.value = value;
			this.next = next;
		}
	}
    
   /**
	 * 重写toString 用于Json输出
	 * @return
	 */
	@Override
	public String toString() {
		StringBuffer sb = new StringBuffer();
		Node p = sentinel.next;
		while (p != sentinel){
			sb.append(","+p.value);
			p = p.next;
		}
		//  StringUtils.strip(sb.toString() 去除首位固定字符
		return "Node[ " + StringUtils.strip(sb.toString(), ",") +" ]";
	}
}

2.2.头部添加数据

# 思路
	找到哨兵，找到哨兵的下一个节点，创建新的对象（指定新节点的前后节点），将哨兵next指向新创建的节点，将哨兵的下一个节点指向新加的节点

在这里插入图片描述

2.2.1.具体实现
	/**
	 * 在头部添加值
	 * @param value 待添加的元素
	 */
	public void addFirst(int value){
		// 找到哨兵
		Node head = sentinel;
		// 找到哨兵的下一个节点
		Node next = sentinel.next;
		// 创建新的对象
		Node addNode = new Node(head, value, next);
		// 将哨兵next指向新创建的节点
		head.next = addNode;
		//将哨兵的下一个节点的头节点指向新加的节点
		next.prev = addNode;
	}
2.2.2.测试添加数据
@Test
@DisplayName("测试双向环形链表")
public void test(){
    DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
    logger.error("add after node :{}",node);
    node.addFirst(1);
    node.addFirst(2);
    node.addFirst(3);
    logger.error("add after node :{}",node);
}

在这里插入图片描述

2.3.尾部添加数据

# 思路
	找到最后一个节点，找到头节点，创建新的节点（指明前后节点），将最后一个节点的next指向新创建的节点，将头节点的prev指向新创建的节点

在这里插入图片描述

2.3.1.具体实现
/**
 * 向链表的最后一个节点添元素
 * @param value 需要添加元素的值
 */
public void addLast(int value){
    // 找到最后一个节点
    Node next = sentinel.prev;
    // 找到头节点
    Node head = sentinel;
    // 创建新的节点
    Node node = new Node(next, value, head);
    // 将最后一个节点的next指向新创建的节点
    next.next = node;
    // 将头节点的prev指向新创建的节点
    head.prev = node;
}
2.3.2.添加测试数据
	@Test
	@DisplayName("测试-双向环形链表-尾部添加元素")
	public void tes2(){
		DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
		node.addLast(1);
		node.addLast(2);
		node.addLast(3);
		node.addLast(4);
		logger.error("linked list is: :{}",node);
	}

在这里插入图片描述

2.4.删除头部数据

# 思路 
	找到需要删除的节点，找到上一个节点，找到删除节点的下一个节点，将头节点的next指向删除节点的下一个节点，将删除节点的prev指向head

在这里插入图片描述

2.4.1.具体实现
/**
 * 删除第一个节点
 */
public void removedFirst(){
    // 先找到需要删除的节点
    Node deleteNode = sentinel.next;
    // 如果删除的节点等于哨兵 那么不能删除
    if (deleteNode == sentinel){
        throw new IllegalArgumentException("delete node is null!");
    }
    // 找到上一个节点
    Node head = sentinel;
    // 找到删除节点的下一个节点
    Node next = deleteNode.next;
    // 将头节点的next指向删除节点的下一个节点
    head.next = next;
    // 将删除节点的prev指向head
    next.prev = head;
}
2.4.2.测试删除数据
@Test
@DisplayName("测试-双向环形链表-删除第一个数据")
public void tes2(){
    DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
    node.addLast(1);
    node.addLast(2);
    node.addLast(3);
    node.addLast(4);
    logger.error("remove first node :{},size :{}",node,node.size());
    logger.error("------------------ remove ----------------");
    node.removedFirst();
    logger.error("remove first node :{},size :{}",node,node.size());
    node.removedFirst();
    logger.error("remove first node :{},size :{}",node,node.size());
    node.removedFirst();
    logger.error("remove first node :{},size :{}",node,node.size());
    node.removedFirst();
    logger.error("remove first node :{},size :{}",node,node.size());
    node.removedFirst();
}

在这里插入图片描述

2.5.删除尾部数据

# 思路
	找到最后一个节点，找到删除节点的上一个节点，找到删除节点的下一个节点，将删除节点的上一个节点 next指向头部，将哨兵执行最后一个节点

在这里插入图片描述

2.5.1.具体实现
/**
	 * 删除最后一个节点
	 */
	public void removeLast(){
		// 找到最后一个节点
		Node deleteNode = sentinel.prev;
		// 如果删除的节点等于哨兵 那么不能删除
		if (deleteNode == sentinel){
			throw new IllegalArgumentException("delete node is null!");
		}
		// 找到删除节点的上一个节点
		Node head = deleteNode.prev;
		// 将删除节点的下一个节点
		Node next = sentinel;
		// 将删除的节点的上一个节点 next指向头部
		head.next = next;
		// 将哨兵执行最后一个节点
		next.prev = head;
	}
2.5.2.测试删除数据
@Test
@DisplayName("测试-双向环形链表-删除最后一个数据")
public void tes2(){
    DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
    node.addLast(1);
    node.addLast(2);
    node.addLast(3);
    node.addLast(4);
    logger.error("remove last node :{},size :{}",node,node.size());
    logger.error("------------------ remove ----------------");
    node.removeLast();
    logger.error("remove last node :{},size :{}",node,node.size());
    node.removeLast();
    logger.error("remove last node :{},size :{}",node,node.size());
    node.removeLast();
    logger.error("remove last node :{},size :{}",node,node.size());
    node.removeLast();
    logger.error("remove last node :{},size :{}",node,node.size());
    node.removeLast();
}

在这里插入图片描述

2.6.根据内容删除节点

# 思路
	找到需要删除的节点，找到删除节点的上一个节点，找到删除节点的下一个节点，将删除节点的上一个节点 next指向删除节点的下一个节点，将删除节点的下一个节点 prev指向删除节点的上一个节点

在这里插入图片描述

2.6.1.具体实现
@Test
@DisplayName("测试-双向环形链表-根据内容删除元素")
public void tes2(){
    DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
    node.addLast(1);
    node.addLast(2);
    node.addLast(3);
    node.addLast(4);
    int r1 = RandomUtils.nextInt(1, 5);
    int r2 = RandomUtils.nextInt(1, 10);
    logger.error("linked list :{}",node);
    int i = node.removeByIndex(r1);
    if (i == -1){
        logger.error("未找到需要删除的元素,{}",r1);
    }else {
        logger.error("删除成功,{}",r1);
    }
    int j = node.removeByIndex(r2);
    if (j == -1){
        logger.error("未找到需要删除的元素,{}",r2);
    }else {
        logger.error("删除成功,{}",r2);
    }
    logger.error("find linked list :{}",node);
}

在这里插入图片描述

2.7.遍历环形链表

2.7.1.迭代器遍历
// 实现 public class DoubleLinkedListSentinel implements Iterable<Integer> 接口  重写

/**
 * 通过实现迭代器 进行循环遍历
 */
@Override
public Iterator<Integer> iterator() {
    return new Iterator<Integer>() {
        Node p = sentinel.next;
        @Override
        public boolean hasNext() {
            return p != sentinel;
        }

        @Override
        public Integer next() {
            Integer value = p.value;
            p = p.next;
            return value;
        }
    };
}
2.7.2.使用递归进行遍历
/**
 * 递归遍历(递归遍历)
 */
public void loop(Consumer<Integer> before,Consumer<Integer> after){
    recursion(sentinel.next,before,after);
}

/**
 * 递归进行遍历
 * @param node   下一个节点
 * @param before 遍历前执行的方法
 * @param after  遍历后执行的方法
 * @deprecated  递归遍历,不建议使用,递归深度过大会导致栈溢出。建议使用迭代器,或者循环遍历,或者使用尾递归,或者使用栈
 * @see #loop(Consumer, Consumer)
 */
public void recursion(Node node, Consumer<Integer> before, Consumer<Integer> after){
    // 表示链表没有节点了，那么就退出(注意 环形链表的 末尾 不是null 而是头节点)
    if (node == sentinel){
        return;
    }
    // 反转位置就是逆序了
    before.accept(node.value);
    recursion(node.next, before, after);
    after.accept(node.value);
}

2.7.3.测试

	@Test
	@DisplayName("测试-双向环形链表-遍历")
	public void tes3(){
		DoubleLinkedListSentinel node = new DoubleLinkedListSentinel();
		node.addLast(1);
		node.addLast(2);
		node.addLast(3);
		node.addLast(4);
		logger.error("=========== 迭代器遍历链表 ===========");
		for (Integer i : node) {
			logger.error("迭代器遍历链表 :{}",i);
		}

		logger.error("=========== 递归遍历链表 ===========");
		node.loop(it->{
			logger.error("从头部开始遍历 :{}",it);
		},it ->{
			logger.error("从尾部开始遍历 :{}",it);
		});

	}

在这里插入图片描述

3.具体应用场景

3.1.优点

  1. 循环遍历简便： 由于双向环形链表形成了一个闭环，因此在需要循环遍历链表时，可以更加简便地实现，不需要额外的指针变量来记录链表的尾部或头部。
  2. 高效的插入和删除操作： 双向环形链表的节点结构允许在任意位置进行节点的插入和删除操作，并且这些操作通常比较高效，尤其是在头部和尾部进行操作时。
  3. 适用于循环结构数据： 对于需要处理循环结构的数据或需要实现环形队列等特定功能的场景，双向环形链表是一种很自然的数据结构选择。

3.2.缺点

  1. 强引用导致的内存泄漏： 如果双向环形链表中的节点持有对外部对象的强引用，并且这些外部对象的生命周期比链表更长，那么即使链表中的节点不再被使用，这些节点仍然被链表中的引用所持有，从而无法被垃圾回收器回收，导致内存泄漏。
  2. 未正确处理节点的引用关系： 在双向环形链表中，节点之间相互引用，如果在节点删除或者替换的过程中未正确地处理节点之间的引用关系，可能会导致链表中的节点无法被回收，从而引发内存泄漏。
  3. 长期持有迭代器： 如果在遍历双向环形链表的过程中长期持有迭代器对象，而没有正确地释放迭代器对象，可能会导致链表中的节点无法被回收，造成内存泄漏。
  4. 容易产生死循环： 由于环形链表的特性，编写循环遍历的代码时需要特别小心，如果没有正确地处理循环结束的条件，可能会产生死循环，导致程序崩溃或陷入无限循环。
  5. 实现复杂度较高： 相比于普通的单向链表，双向环形链表的实现复杂度较高，需要更多的代码来维护节点之间的引用关系，尤其是在节点的插入和删除操作时需要考虑更多的边界条件。

3.3.应用场景

  1. LRU Cache（最近最少使用缓存）： 在LRU缓存中，双向环形链表可以用于维护最近使用的数据项的顺序。每次访问缓存中的数据时，可以将该数据项移到链表的头部，而最少使用的数据项则会被移动到链表的尾部，当缓存空间不足时，可以删除链表尾部的数据项。双向环形链表使得在链表头尾进行插入和删除操作更加高效。
  2. 循环队列： 在某些情况下，需要实现循环队列以存储和处理数据，比如在生产者-消费者模型中。双向环形链表可以用作循环队列的基础数据结构，使得在队列头尾进行数据插入和删除操作更加高效。
  3. 哈希表的冲突解决： 在哈希表中，如果多个键散列到相同的槽位上，就会发生冲突。双向环形链表可以用作哈希表中槽位的链表，用于解决冲突，实现链地址法（Separate Chaining）的哈希表。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1453716.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【leetcode】深搜、暴搜、回溯、剪枝（C++）3

【leetcode】深搜、暴搜、回溯、剪枝（C++）3

深搜、暴搜、回溯、剪枝&#xff08;C&#xff09;3 一、解数独1、题目描述2、代码3、解析 二、单词搜索1、题目描述2、代码3、解析 三、黄金矿工1、题目描述2、代码3、解析 四、不同路径III1、题目描述2、代码3、解析 一、解数独 1、题目描述 leetcode链接 2、代码 class…
阅读更多...
BIG DATA —— 大数据时代

BIG DATA —— 大数据时代

大数据时代 [英] 维克托 迈尔 — 舍恩伯格 肯尼斯 库克耶 ◎ 著 盛杨燕 周涛◎译 《大数据时代》是国外大数据研究的先河之作&#xff0c;本书作者维克托迈尔舍恩伯格被誉为“大数据商业应用第一人”&#xff0c;他在书中前瞻性地指出&#xff0c;大数据带来的信息…
阅读更多...
微服务—DSL基础语法与RestClient操作

微服务—DSL基础语法与RestClient操作

本博客为个人学习笔记&#xff0c;学习网站&#xff1a;黑马程序员SpringCloud 2021教程 目录 DSL语法 索引库操作 mapping属性 创建索引库 字段拷贝 查询、删除、修改索引库 文档操作 新增文档 查询、删除文档 修改文档 全量修改 增量修改 DSL文档语法小结 Rest…
阅读更多...
Mac配置Python3最简单的方法

Mac配置Python3最简单的方法

此文介绍Mac用Anaconda配置Python3 达成效果 能让你目前只装有Python2的Mac装上Python3&#xff0c;同时拥有很多科学计算库 anaconda介绍 anaconda 是一个python的发行版&#xff0c;包括了python和很多常见的软件库, 和一个包管理器conda。常见的科学计算类的库都包含在里…
阅读更多...
美国突然致敬中本聪

美国突然致敬中本聪

作者&#xff1a;秦晋 有点看不懂美国的神操作。 2月16日&#xff0c;据《Bitcoin Magazine》报道&#xff0c;比特币的竞争对手、美国参议员伊丽莎白-沃伦对比特币的立场突然180度大转弯。由反对立场转为支持立场。让很多行业媒体出乎意料&#xff0c;甚至惊掉下巴。 报道称&a…
阅读更多...
【测试】JUnit

【测试】JUnit

目 录 一.注解二.断言三.用例的执行顺序四.参数化五.测试套件 自动化就是 selenium 脚本来实现的 junit 是 java 的单亓测试工具&#xff0c;只不过我们在实现自动化的时候需要借用一下下 junit 库里面提供的一些方法 引入依赖 Junit 5 <!-- https://mvnrepository.com/a…
阅读更多...
php 数组函数

php 数组函数

php 数组函数 1. 常用的php数组函数 1. 常用的php数组函数 array_pop() 删除数组中最后一个元素 array_push() 将一个或多个元素插入到数组的末尾 array_keys <?php $arr array("刘岩" > 30, "范冰冰" > 31, "娜扎" > 31);$…
阅读更多...
DS：八大排序之堆排序、冒泡排序、快速排序

DS：八大排序之堆排序、冒泡排序、快速排序

创作不易&#xff0c;友友们给个三连吧&#xff01;&#xff01; 一、堆排序 堆排序已经在博主关于堆的实现过程中详细的讲过了&#xff0c;大家可以直接去看&#xff0c;很详细,这边不介绍了 DS&#xff1a;二叉树的顺序结构及堆的实现-CSDN博客 直接上代码&#xff1a; …
阅读更多...
备战蓝桥杯---图论之最小生成树

备战蓝桥杯---图论之最小生成树

首先&#xff0c;什么是最小生成树&#xff1f; 他就是无向图G中的所有生成树中树枝权值总和最小的。 如何求&#xff1f; 我们不妨采用以下的贪心策略&#xff1a; Prim算法&#xff08;复杂度&#xff1a;&#xff08;nm)logm)&#xff1a; 我们对于把上述的点看成两个集…
阅读更多...
MAC VSCODE g++编译器无法编译C++11语法的 解决办法（CodeRunner版本）

MAC VSCODE g++编译器无法编译C++11语法的 解决办法（CodeRunner版本）

如果你是使用的 codeRunner 这个插件&#xff0c;就是这个按钮 coderunner的原理大致是&#xff1a;先判断你这是什么语言&#xff0c;然后有一个 code-runner.executorMap 来对应各个语言是用什么执行语句 我发现&#xff0c;我修改之前&#xff08;无法执行C11语法的原因是&a…
阅读更多...
智能汽车专题：智能驾驶2023年度报告

智能汽车专题：智能驾驶2023年度报告

今天分享的是智能汽车系列深度研究报告&#xff1a;《智能汽车专题&#xff1a;智能驾驶2023年度报告》。 &#xff08;报告出品方&#xff1a;量子位智库&#xff09; 报告共计&#xff1a;30页 来源&#xff1a;人工智能学派 顶天立地&#xff1a;技术进阶路线明晰 根据…
阅读更多...
echarts制作两个柱状图

echarts制作两个柱状图

let colorList[#02ce8b,#ffbe62,#f17373]; let data1 [90,80,70,50] option { title:[{ // 第一个标题text: 环保检测, // 主标题textStyle: { // 主标题样式color: #333,fontWeight: bold,fontSize: 16},left: 20%, // 定位到适合的位置top: 10%, // 定位到适合的位置},{ //…
阅读更多...
小程序获取手机号：快速验证和实时验证

小程序获取手机号：快速验证和实时验证

概述 小程序手机号快速验证和实时验证都已经开始收费了。 手机号实时验证组件&#xff0c;在每次请求时&#xff0c;平台均会对用户选择的手机号进行实时验证&#xff1b;每次组件调用成功&#xff0c;收费0.04元手机号快速验证组件&#xff0c;平台会对号码进行验证&#xf…
阅读更多...
论文阅读_语音识别_Wisper

论文阅读_语音识别_Wisper

英文名称: Robust Speech Recognition via Large-Scale Weak Supervision 中文名称: 通过大规模弱监督实现鲁棒语音识别 链接: https://proceedings.mlr.press/v202/radford23a.html 代码: https://github.com/openai/whisper 作者: Alec Radford, Jong Wook Kim, Tao Xu, Greg…
阅读更多...
基于协同过滤的时尚穿搭推荐系统

基于协同过滤的时尚穿搭推荐系统

项目&#xff1a;基于协同过滤的时尚穿搭推荐系统 摘 要 基于协同过滤的时尚穿搭推荐系统是一种能自动从网络上收集信息的工具&#xff0c;可根据用户的需求定向采集特定数据信息的工具&#xff0c;本项目通过研究服饰流行的分析和预测的分析和预测信息可视化时尚穿搭推荐系统…
阅读更多...
2024免费人像摄影后期处理工具Portraiture4.1

2024免费人像摄影后期处理工具Portraiture4.1

Portraiture作为一款智能磨皮插件&#xff0c;确实为Photoshop和Lightroom用户带来了极大的便利。通过其先进的人工智能算法&#xff0c;它能够自动识别并处理照片中的人物皮肤、头发和眉毛等部位&#xff0c;实现一键式的磨皮美化效果&#xff0c;极大地简化了后期处理的过程。…
阅读更多...
STM32下载后需要复位

STM32下载后需要复位

下载后需要复位才能自动运行程序&#xff0c;需要以下两步 STEP1 STEP2 一个勾选&#xff0c;一个不勾选。
阅读更多...
乡政府|乡政府管理系统|基于Springboot的乡政府管理系统设计与实现(源码+数据库+文档)

乡政府|乡政府管理系统|基于Springboot的乡政府管理系统设计与实现(源码+数据库+文档)

乡政府管理系统目录 目录 基于Springboot的乡政府管理系统设计与实现 一、前言 二、系统功能设计 三、系统实现 1、用户信息管理 2、活动信息管理 3、新闻类型管理 4、新闻动态管理 四、数据库设计 1、实体ER图 五、核心代码 六、论文参考 七、最新计算机毕设选题推…
阅读更多...
内存块与内存池

内存块与内存池

&#xff08;1&#xff09;在运行过程中&#xff0c;MemoryPool内存池可能会有多个用来满足内存申请请求的内存块&#xff0c;这些内存块是从进程堆中开辟的一个较大的连续内存区域&#xff0c;它由一个MemoryBlock结构体和多个可供分配的内存单元组成&#xff0c;所有内存块组…
阅读更多...
JAVA之Java线程核心详解

JAVA之Java线程核心详解

Java线程核心 1.进程和线程 进程&#xff1a;进程的本质是一个正在执行的程序&#xff0c;程序运行时系统会创建一个进程&#xff0c;并且给每个进程分配独立的内存地址空间保证每个进程地址不会相互干扰。同时&#xff0c;在 CPU 对进程做时间片的切换时&#xff0c;保证进程…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023