数据结构（Java）——链表

最新推荐文章于 2024-09-17 15:19:12 发布
最新推荐文章于 2024-09-17 15:19:12 发布
阅读量130 收藏
点赞数
分类专栏： 笔记 Java 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FallToHer/article/details/120395103
版权
笔记 同时被 2 个专栏收录
32 篇文章 0 订阅
订阅专栏
Java
19 篇文章 0 订阅
订阅专栏

链表

链表就是有序列表，如同C++指针，链表是用节点的方式来存储，每个节点包含data域和next域，各个节点不一定连续储存,y以下的链表是带头结点的链表

实际应用——增删改查

增加节点

这里提前声明一下，temp是个辅助变量，因为不能改变头节点，临时储存节点数据的作用

添加时(不按顺序添加时)——先遍历链表，找到最后一个节点temp.next = null；，这时将temp.next = newNode;即可
在这里插入图片描述
代码如下

private HeroNode head = new HeroNode(0,"","");//初始化的头节点不妨数据
	//添加节点到单向链表;
	//思路，当不考虑编号顺序时
	//1.找到当前链表的最后节点
	//2.将最后这个节点的next指向新的节点

	public void addNode(HeroNode heroNode) {
		HeroNode temp = head;//由于head节点不能动，找个变量辅助查找
		while(true) {//遍历链表，找到最后一个节点
			if(temp.next == null) {
				break;
			}
			temp = temp.next;//没有找到就将temp后移
		}
		temp.next = heroNode;
	}

添加时（按顺序添加时）——先遍历链表，让temp == head； 当 temp.next = null； 时表示链表为空，当temp.next.no > newNode.no时，表示当前不是，接着temp= temp.next接着遍历，当temp.no == temp.next.no表示当前节点存在，不可添加，这时找到对应位置的节点用 newNode.next = temp.next; temp.next = newNode;完成插入过程。
在这里插入图片描述

代码如下

	public void add(HeroNode heroNode) {
		HeroNode temp = head;//由于head节点不能动，找个变量辅助查找
		//同时我们找的temp是添加位置的前一个节点，否则插入不了
		boolean flag = false;//标志添加的编号是否存在，默认false
		
		
		while(true) {//遍历链表，找到最后一个节点
			if(temp.next == null) {
				break;
			}
			if(temp.next.no > heroNode.no) {//位置找到了
				break;
			}else if (temp.next.no == heroNode.no) {//编号存在
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.println("任务存在");
		}else {
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
删除节点

想要删除节点就要先遍历找到是否有这个节点，方法同上，找到时，用temp.next = temp.next.next;完成删除，被删除的节点由于不用会被垃圾回收机制回收掉。

在这里插入图片描述
代码如下

//删除节点
	//思路
	//1. head 不能动,因此我们需要- -个temp辅助节点找到待删除节点的前一一个节点
	//2. 说明我们在比较时,是temp. next.no 和需要删除的节点的no比较
	public void del(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; //temp后移， 遍历
		}
		//判断flag
		if(flag) {
			temp.next = temp.next.next;
		}else {
			System.out.println("这个节点不存在");
		}
	}
修改节点

想要修改节点就要先遍历找到是否有这个节点，方法同上，找到时，直接将修改的内容进行相应的修改就行temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname

代码如下

//修改节点的信息，根据no编号来修改,即no编号不能改
	
	public void update(HeroNode newHeroNode) {
		//判断是否空
		if(head.next == null) {
			System.out.println("链表为空~"); 
			return;
		}
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false; //表示是否找到该节点
		while(true) {
			if (temp == null) {
				break; //已经遍历完链表
			}
			if(temp.no == newHeroNode. no) {
				flag = true;
				break;
			}
			temp = temp.next;

		}
		//根据flag判断是否找到要修改的节点
		if(flag) {
			temp.name = newHeroNode.name ;
			temp.nickname = newHeroNode.nickname;
		} else { //没有找到
			System.out. printf("没有找到编号%d的节点，不能修改\n", newHeroNode.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);//输出节点的信息
			temp = temp.next;//后移
		}
	}

完整代码

package linkedlist;

public class SingleLinkedList {
	public static void main(String[] args) {
		//创建节点
		HeroNode hero1 = new HeroNode(1, "11","111");
		HeroNode hero2 = new HeroNode(2, "22","222");
		HeroNode hero3 = new HeroNode(3, "33","333");
		HeroNode hero4 = new HeroNode(4, "44","444");
		SingleLinkedListTest singleLinkedListTest = new SingleLinkedListTest();
		singleLinkedListTest.addNode(hero1);
		singleLinkedListTest.addNode(hero2);
		singleLinkedListTest.addNode(hero3);
		singleLinkedListTest.addNode(hero4);
		singleLinkedListTest.list();
		//创建节点2
		HeroNode hero11 = new HeroNode(1, "11","111");
		HeroNode hero21 = new HeroNode(2, "22","222");
		HeroNode hero31 = new HeroNode(3, "33","333");
		HeroNode hero41 = new HeroNode(4, "44","444");
		SingleLinkedListTest singleLinkedListTest2 = new SingleLinkedListTest();
		singleLinkedListTest2.add(hero21);
		singleLinkedListTest2.add(hero11);
		singleLinkedListTest2.add(hero41);
		singleLinkedListTest2.add(hero31);
		singleLinkedListTest2.add(hero31);
		singleLinkedListTest2.list();
		//修改节点
		HeroNode hero311 = new HeroNode(3, "331","3331");
		singleLinkedListTest.update(hero311);
		System.out.println("修改后");
		singleLinkedListTest.list();
		//删除节点
		
		singleLinkedListTest.del(4);
		System.out.println("删除后");
		singleLinkedListTest.list();
	}
}

//定义一个单列表管理
class SingleLinkedListTest{
	private HeroNode head = new HeroNode(0,"","");//初始化的头节点不妨数据
	//添加节点到单向链表;
	//思路，当不考虑编号顺序时
	//1.找到当前链表的最后节点
	//2.将最后这个节点的next指向新的节点

	public void addNode(HeroNode heroNode) {
		HeroNode temp = head;//由于head节点不能动，找个变量辅助查找
		while(true) {//遍历链表，找到最后一个节点
			if(temp.next == null) {
				break;
			}
			temp = temp.next;//没有找到就将temp后移
		}
		temp.next = heroNode;
	}
	
	
	public void add(HeroNode heroNode) {
		HeroNode temp = head;//由于head节点不能动，找个变量辅助查找
		//同时我们找的temp是添加位置的前一个节点，否则插入不了
		boolean flag = false;//标志添加的编号是否存在，默认false
		
		
		while(true) {//遍历链表，找到最后一个节点
			if(temp.next == null) {
				break;
			}
			if(temp.next.no > heroNode.no) {//位置找到了
				break;
			}else if (temp.next.no == heroNode.no) {//编号存在
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.println("任务存在");
		}else {
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
	
	//显示链表[遍历]
	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);//输出节点的信息
			temp = temp.next;//后移
		}
	}
	
	//修改节点的信息，根据no编号来修改,即no编号不能改
	
	public void update(HeroNode newHeroNode) {
		//判断是否空
		if(head.next == null) {
			System.out.println("链表为空~"); 
			return;
		}
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false; //表示是否找到该节点
		while(true) {
			if (temp == null) {
				break; //已经遍历完链表
			}
			if(temp.no == newHeroNode. no) {
				flag = true;
				break;
			}
			temp = temp.next;

		}
		//根据flag判断是否找到要修改的节点
		if(flag) {
			temp.name = newHeroNode.name ;
			temp.nickname = newHeroNode.nickname;
		} else { //没有找到
			System.out. printf("没有找到编号%d的节点，不能修改\n", newHeroNode.no);
		}

	}
	
	//删除节点
	//思路
	//1. head 不能动,因此我们需要- -个temp辅助节点找到待删除节点的前一一个节点
	//2. 说明我们在比较时,是temp. next.no 和需要删除的节点的no比较
	public void del(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; //temp后移， 遍历
		}
		//判断flag
		if(flag) {
			temp.next = temp.next.next;
		}else {
			System.out.println("这个节点不存在");
		}
	}

	

}
//定义 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 + "]" ;
	}
	
}
痞子三分冷ゾジ
关注
专栏目录
java 链表
qq_57163230的博客
06-25 654
Java实现单链表，双向链表，循环链表。
数据结构——链表
m0_61820867的博客
08-26 365
介绍数据结构——链表的相关知识
Java链表
xiangsuixinsheng的专栏
06-11 7165
使用Java实现链表，首先定义链表的数据结构，也就是定义一个类，LinkedListNode。这个定义了链表的节点，链表节点分两部分，数据info和链接link。public class LinkedListNode {   public int info;   public LinkedListNode link;//这里就是链接，指向下一个节点的内存地址}link开始没看懂，怎么l
数据结构与算法——Java实现 5.链表
最新发布
m0_73983707的博客
09-17 740
在计算机科学中，链表是根据数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续寻找链表最后一个元素位置// 1.2 找到最后一个结点// 判断是否为空链表Node p;p.next!= null;return p;// 2.4 删除链表中最后一个节点String.format("链表为空，删除位置不合法"));// 找到倒数第二个节点= null) {return;// 2.1 找到最后一个结点Node p;// 一直遍历直到找到最后一个节点p.next。
Java 链表
weixin_34342207的博客
06-01 70
按链表的组织形式分有ArrayList和LinkList两种。ArrayList内部其实是用数组的形式实现链表，比较适合链表大小确定或较少对链表进行增删操作的情况，同时对每个链表节点的访问时间都是constant；而LinkList内部以一个List实现链表，比较适合需要频繁对链表进行操作的情况，对链表节点的访问时间与链表长度有关O(N)。 另外，根据实现形式可以分为直接式（想不出什...
Java语言中链表和双向链表的实现
myali88的专栏
12-04 916
出处:csdn链表是一种重要的数据结构，在程序设计中占有很重要的地位。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针（本文中的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种线性数据结构，遵循后进先出（LIFO）的原则，意味着最后进入的元素最先被移出。栈的...
Java数据结构——循环链表与双向链表
NoBug
12-21 934
1. 循环链表****** 2. 双向链表******
Java-链表
Subuprogrammer的博客
07-16 203
一、删除链表中所有值等于val的节点 class Solution { public ListNode removeElements(ListNode head, int val) { //先判断链表是否为空 if(head==null){ return null; } ListNode prev=head; ListNode cur=head.next; wh
java链表
04-19
NULL 博文链接：https://wuzexin530.iteye.com/blog/1860709
JAVA链表
qq_45018669的博客
10-19 145
链表与数组的区别： 两者区别： （1）数组静态分配内存，链表动态分配内存。 （2）数组在内存中是连续的，链表是不连续的。 （3）数组利用下标定位，查找的时间复杂度是O(1)，链表通过遍历定位元素，查找的时间复杂度是O(N)。 （4）数组插入和删除需要移动其他元素，时间复杂度是O(N)，链表的插入或删除不需要移动其他元素，时间复杂度是O(1)。 数组的优点： （1）随机访问性比较强，可以通过下标进行...
链表，单向链表的创建，插入，更新，删除操作
qq_40823802的博客
08-09 459
总结： 链表是以节点的方式来存储，是链式存储。 每个节点包含data域，next域：指向下一个节点 链表的各个节点不一定是连续存储。 链表分类：带头节点的链表和没有头结点的。根据实际的需求来确定。 单链表（带头结点）逻辑结构示意图： 添加（创建） 1.先创建一个head头结点，作用就是表示单链表的头。 2.后面我们每添加一个节点，就直接加入到链表的最后 public class Singl...
Java数据结构深入解析：链表详解
本文主要介绍了Java中的数据结构——链表，包括链表的基本概念、单链表和双链表，并探讨了链表相对于数组的优势。 链表是一种在计算机科学中常用的数据结构，它通过节点（Node）之间的引用连接来存储一系列元素。与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

痞子三分冷ゾジ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值