java 链表

已于 2022-06-27 08:34:30 修改
阅读量590 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 数据结构 链表
于 2022-06-25 14:47:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57163230/article/details/125458970
版权

链表介绍

链表是有序的列表，它在内存中存储如下

小结上图:

  1. 链表是以节点的方式来存储,是链式存储
  2. 每个节点包含 data 域， next 域：指向下一个节点.
  3. 如图：发现链表的各个节点不一定是连续存储.
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

链表插入

直接插入到链表的尾部

 添加（创建）

1. 先创建一个head 头节点， 作用就是表示单链表的头

2. 后面我们每添加一个节点，就直接加入到  链表的最后

遍历： 1.  通过一个辅助变量遍历，帮助遍历整个链表

在中间随机一个位置添加节点

1. 首先找到新添加的节点的位置, 是通过辅助变量(指针), 通过遍历来搞定

2. 新的节点.next = temp.next

3. 将temp.next = 新的节点

修改节点

思路

1. 先找到该节点，通过遍历，

2. temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname

删除节点

从单链表中删除一个节点的思路

1.  我们先找到 需要删除的这个节点的前一个节点 temp

2.  temp.next = temp.next.next

3. 被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收 

代码实现

package linkedlist;

public class SingleLinkedListDemo {
	public static void main(String[] args) {
		//先创建节点
		HeroNode hero1 = new HeroNode(1, "宋江", "及时雨"); 
		HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
		HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
		HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
		//
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		//节点添加至链表
		/*
		 * singleLinkedList.add(hero1); singleLinkedList.add(hero4);
		 * singleLinkedList.add(hero2); singleLinkedList.add(hero3);
		 */

		//添加按照编号的顺序
			singleLinkedList.addByOrder(hero1); 
			singleLinkedList.addByOrder(hero4);
		    singleLinkedList.addByOrder(hero2); 
		    singleLinkedList.addByOrder(hero3);
		 
		//遍历
		singleLinkedList.list();

		//测试修改节点的代码
		HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~"); 
		singleLinkedList.update(newHeroNode);

		System.out.println("修改后的链表情况~~");
		singleLinkedList.list();

		//删除一个节点
		singleLinkedList.delete(1); 
		singleLinkedList.delete(4);
		System.out.println("删除后的链表情况~~"); 
		singleLinkedList.list();

		}

}

//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {
	//先初始化一个头节点, 头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0,"","");
	
	/*
	 * 第一种添加英雄（节点）的方式，将节点添加至最后
	 * 添加节点到单向链表 
	 * 1. 找到当前链表的最后节点 
	 * 2. 将最后这个节点的 next 指向新的节点 
	 */
	public void add(HeroNode heroNode) {
		//因为 head 节点不能动，因此我们需要一个辅助节点遍历 temp 
		HeroNode temp = head;
		//遍历节点，找到最后
		while(true) {
			if(temp.next == null) {
				break;
			}
			//没找到最后一个节点时，将temp后移
			temp = temp.next;
		}
		//此时temp就指向了链表的最后
		//将最后这个节点的next指向新的节点
		temp.next = heroNode;
	}
	
	/*
	 * 第二种添加英雄（节点）的方式，根据编号将英雄插入到指定位置（按编号从小到大）
	*/
	public void addByOrder(HeroNode heroNode) {
		//因为 head 节点不能动，因此我们需要一个辅助节点遍历 temp
		//temp 是位于 添加位置的前一个节点
		HeroNode temp = head;
		boolean flag = false; // flag 标志添加的编号是否存在
		while(true) {
			if(temp.next == null) {//temp 已经到链表的最后,插入到链表最后
				break;
			}
			if(temp.next.no > heroNode.no) {//位置找到，就在 temp 的后面插入
				break;
			}else if(temp.next.no == heroNode.no) {//该编号已经存在
				flag = true; //编号已存在
				break;
			}
			temp = temp.next;
		}
		
		if(flag) { //不能添加，说明编号存在
			System.out.println("编号" + heroNode.no + "已经存在，不能添加");
		}else {
			//节点插入到temp的后面
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
	
	//修改节点的信息, 根据 no 编号来修改，即 no 编号不能改
	public void update(HeroNode newHeroNode) {
		if(head.next == null) {
			System.out.println("链表为空");
			return ;
		}
		//找到需要修改的节点,定义一个辅助变量temp
		HeroNode temp = head.next;
		boolean flag = false; //是否找到该节点
		while(true) {
			if(temp == null) {
				break;//遍历完链表了，没找到该节点
			}
			if(temp.no == newHeroNode.no) {
				//找到了
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {//找到了
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}else {//没找到
			System.out.println("没有找到编号为" + newHeroNode.no + "的节点" );
		}
	}
	
	/*  
	 *   删除节点
	*/
	public void delete(int no) {
		HeroNode temp = head;
		boolean flag = false;
		while(true) {
			if(temp.next == null) {
				break;
			}
			if(temp.next.no == no) {
				//找到待删除节点的前一个节点 temp
				flag = true;
				break;
			}
			temp = temp.next;
		}
		
		if(flag) { //有该节点，删除
			temp.next = temp.next.next;
		}else {
			System.out.println("没有找到编号为" + no + "的节点");
		}
	}
	
	//遍历链表
	public void list() {
		if(head.next == null) {
			System.out.println("链表为空"); 
			return ;
		}
		
		HeroNode temp = head.next;
		while(true) {
			if(temp == null) {
				break;
			}
			System.out.println(temp.no + "\t" + temp.name + "\t" + temp.nickname );
			temp = temp.next;
		}
	}
	
	
}


//定义 HeroNode ， 每个 HeroNode 对象就是一个节点
class HeroNode {
	public int no;
	public String name;
	public String nickname;
	public HeroNode next; // 指向下一个节点
	
	public HeroNode(int no,String name,String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + ", next=" + next + "]";
	}
	
	
}

双向链表

双向链表的操作分析和实现

管理单向链表的缺点分析

  •  单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
  • 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单         链表删除时节点，总是找到 temp,temp 是待删除节点的前一个节点.

分析 双向链表的遍历，添加，修改，删除的操作思路===》

1) 遍历 方法和 单链表一样，只是可以向前，也可以向后查找

2) 添加 (默认添加到双向链表的最后)

        (1) 先找到双向链表的最后这个节点

        (2) temp.next = newHeroNode

        (3) newHeroNode.pre = temp;

3) 修改 思路和 原来的单向链表一样.

4) 删除

        (1) 因为是双向链表，因此，我们可以实现自我删除某个节点

        (2) 直接找到要删除的这个节点，比如temp

         (3)  temp.pre.next = temp.next

        (4) temp.next.pre = temp.pre; 

双向链表的代码实现

package linkedlist;

public class DoubleLinkedListDemo {
	public static void main(String[] args) {
		//测试
		System.out.println("双向链表的测试");
		// 先创建节点
		HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨"); 
		HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
		HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星"); 
		HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
		// 创建一个双向链表
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		doubleLinkedList.add(hero1);
		doubleLinkedList.add(hero2);
		doubleLinkedList.add(hero3); 
		doubleLinkedList.add(hero4);

		doubleLinkedList.list();

		// 修改
		HeroNode2 newHeroNode = new HeroNode2(4, "公孙胜", "入云龙"); 
		doubleLinkedList.update(newHeroNode);
		System.out.println("修改后的链表情况");
		doubleLinkedList.list();

		// 删除
		doubleLinkedList.delete(2);
		System.out.println("删除后的链表情况~~"); 
		doubleLinkedList.list();

	}

}

//创建一个双向链表的类
class DoubleLinkedList {
	
	// 先初始化一个头节点, 头节点不要动, 不存放具体的数据
	private HeroNode2 head = new HeroNode2(0,"","");
	
	//返回头节点
	public HeroNode2 getHead() {
		return head;
	}
	
	//遍历
	public void list() {
		if(head.next == null) {
			System.out.println("链表为空");
			return ;
		}
		HeroNode2 temp = head.next; //辅助节点
		while(true) {
			if(temp == null) {
				break;
			}
			System.out.println(temp.no + "\t" + temp.name + "\t" + temp.nickName );
			temp = temp.next;
		}
	}
	
	//添加节点到链表尾
	public void add(HeroNode2 heroNode2) {
		HeroNode2 temp = head;
		while(true) {
			//找到链表的最后
			if(temp.next == null) {
				break;
			}
			temp = temp.next;
		}
		//退出循环，temp指向链表最后
		temp.next = heroNode2;
		heroNode2.pre = temp;
	}
	
	// 修改一个节点的内容
	public void update(HeroNode2 newHeroNode2) {
		if(head.next == null) {
			System.out.println("链表为空");
			return ;
		}
		HeroNode2 temp = head.next;
		boolean flag = false; // 表示是否找到该节点
		while(true) {
			if(temp == null) {
				break; //已经遍历完了链表，没找到需要修改的节点
			}
			if(temp.no == newHeroNode2.no) {
				//找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		
		if(flag) {
			temp.name = newHeroNode2.name;
			temp.nickName = newHeroNode2.nickName;
		}else {
			System.out.println("没有找到编号为" + newHeroNode2.no + "的节点，不能修改" );
		}
	}
	
	// 从双向链表中删除一个节点
	public void delete(int no) {
		if(head.next == null) {
			System.out.println("链表为空");
			return ;
		}
		HeroNode2 temp = head.next;
		boolean flag = false;
		while (true) {
			if (temp == null) { // 已经到链表的最后
				break;
			}
			if (temp.no == no) {
			// 找到的待删除节点 temp 
				flag = true;
				break;
			}
			temp = temp.next; // temp 后移，遍历
		}
		
		if (flag) { // 找到 可以删除
			temp.pre.next = temp.next;
			// 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
			if (temp.next != null) { 
				temp.next.pre = temp.pre;
			}
		} else {
			System.out.printf("要删除的" + no + "不存在");
			}

	}
	
}

//定义 HeroNode2 ， 每个 HeroNode 对象就是一个节点
class HeroNode2 {
	public int no;
	public String name;
	public String nickName;
	public HeroNode2 next; //指向下一个节点
	public HeroNode2 pre; //指向前一个节点
	
	public HeroNode2(int no, String name, String nickName)  {
		 this.no = no;
		 this.name = name; 
		 this.nickName = nickName;
	}
	@Override
	public String toString() {
	return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickName + "]";

	}
}

单向环形链表

Josephu(约瑟夫、约瑟夫环) 问题

Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

 

 

问题分析：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。

 构建一个单向的环形链表思路

1. 先创建第一个节点, 让 first 指向该节点，并形成环形

2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.

遍历环形链表

1. 先让一个辅助指针(变量) curBoy，指向first节点

2. 然后通过一个while循环遍历 该环形链表即可 curBoy.next  == first 结束

约瑟夫问题-节点出圈的思路分析图

 

代码实现

package linkedlist;

public class Josepfu {
	public static void main(String[] args) {
		// 测试一把看看构建环形链表，和遍历是否 ok
		CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);// 加入 5 个节点
		circleSingleLinkedList.showBoy();//遍历链表


		//测试节点出圈是否正确
		circleSingleLinkedList.countBoy(3, 7, 5); // 4->2->3->5->1
	}
}

//创建一个环形的单向链表
class CircleSingleLinkedList {
	// 创建一个 first 节点,当前没有编号
	private Boy first = null;
	
	//添加节点，构建一个环形链表
	public void addBoy(int nums) {
		if(nums < 1) {
			System.out.println("nums 的值不正确"); 
			return ;
		}
		Boy curBoy = null; // 辅助指针，帮助构建环形链表
		
		for (int i = 1; i <= nums; i++) {
			// 根据编号，创建节点
			Boy boy = new Boy(i);
			// 如果是第一个节点
			if (i == 1) {
				first = boy; 
				first.setNext(first); // 构成环
				curBoy = first; // 让 curBoy 指向第一个节点
			} else {
				curBoy.setNext(boy);//
				boy.setNext(first);//
				curBoy = boy;
			}
		}
	}
	
	// 遍历当前的环形链表
	public void showBoy() {
		// 判断链表是否为空
		if (first == null) {
			System.out.println("没有节点~~"); 
			return ;
		}
		// 因为 first 不能动，因此我们仍然使用一个辅助指针完成遍历
		Boy curBoy = first; 
		while (true) {
			System.out.printf("节点的编号 %d \n", curBoy.getNo());
			if (curBoy.getNext() == first) {// 说明已经遍历完毕
				break;
			}
			curBoy = curBoy.getNext(); // curBoy 后移
			}
		}
	
	/**
	*根据用户的输入，计算出节点出圈的顺序
	*
	*@param startNo
	*	表示从第几个节点开始报数
	*@param countNum
	*	表示数几下
	*@param nums
	*	表示最初有多少节点在圈中
	*/
	public void countBoy(int startNo, int countNum, int nums) {
		// 先对数据进行校验
		if (first == null || startNo < 1 || startNo > nums) {
			System.out.println("参数输入有误， 请重新输入");
			return;
		}
		// 创建要给辅助指针,帮助完成节点出圈
		Boy helper = first;
		// 需求创建一个辅助指针(变量) helper ,  事先应该指向环形链表的最后这个节点
		while (true) {
			if (helper.getNext() == first) { // 说明 helper 指向最后节点
				break;
			}
			helper = helper.getNext();
		}

		//节点报数前，先让 first 和	helper 移动 startNo - 1 次
		for(int j = 0; j < startNo - 1; j++) { 
			first = first.getNext();
			helper = helper.getNext();

		}
		//当节点报数时，让 first 和 helper 指针同时的移动 	m - 1 次, 然后出圈
		//这里是一个循环操作，直到圈中只有一个节点
		while(true) {
		if(helper == first) { //说明圈中只有一个节点
			break;
		}
		//让 first 和 helper 指针同时 的移动 countNum - 1 
		for(int j = 0; j < countNum - 1; j++) {
			first = first.getNext(); 
			helper = helper.getNext();
		}
		//这时 first 指向的节点，就是要出圈的节点节点
		System.out.printf("节点%d 出圈\n", first.getNo());
		//这时将 first 指向的节点出圈
		first = first.getNext(); 
		helper.setNext(first); //

		}
		System.out.printf("最后留在圈中的节点编号%d \n", first.getNo());
	}
}

// 创建一个 Boy 类，表示一个节点
class Boy {
	private int no;
	private Boy next;
	
	public Boy(int no) {
		this.no = no;
	}
	
	public int getNo() {
		return no;
	}
	public Boy getNext() {
		return next;
	}
	public void setNext(Boy next) {
		this.next = next;
	}
	public void setNo(int no) {
		this.no = no;
	}
	

}

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构之链表
m0_74195366的博客
11-06 383
JAVA链表单链表
JAVA——链表
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
数据结构——链表(java)
薯条和番茄酱的博客
01-03 3978
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
【Java】链表LinkedList
qq_61635026的博客
07-06 5993
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
Java中的链表
weixin_52758364的博客
12-09 3239
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
java链表实现的例子
最新发布
12-20
链表
java链表反转及排序
09-01
本资料实例讲解java单项链表的实现以及拓展进行排序，每行代码都附有注释
Java链表（Linked List）基本原理与实现方法入门示例
08-19
主要介绍了Java链表（Linked List）基本原理与实现方法,结合实例形式分析了Java链表（Linked List）的功能、原理、实现方法与操作注意事项,需要的朋友可以参考下
Java链表元素查找实现原理实例解析
08-18
主要介绍了Java链表元素查找实现原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JAVA实现链表面试题
09-03
主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。
Java数据结构篇之链表
MasterJundarj的博客
09-23 1468
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
JAVA基础-链表
lwxklts的博客
02-02 682
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
Java链表详解--通俗易懂(超详细,含源码)
热门推荐
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 870
Java算法链表的深究
Java实现链表
cainiaowangdake的博客
06-06 1102
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
Java数据结构—链表（Linked List）
Rxq_Future的博客
04-16 417
数据结构—链表
一篇讲完Java链表（单链表、循环链表和双向链表）
qq_42592994的博客
07-31 4831
链表，是Java中的一种重要的链式数据结构。 众所周知，我们日常用手机电脑收发信息，下载视频和软件，都要进行数据的传输。这些数据都要以一种特定的数据结构来进行传输和存储，否则数据将会是一串毫无意义的0和1，无法生成我们想要的文件。一般来说有两种最常见的基本数据结构，一种是线性结构的数组，一种是链式结构的链表。
Java链表基础
qq_46638003的博客
01-07 2050
以上是对链表的基础操作,大部分都是通过遍历链表实现.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值