④算法与数据结构-java-链表

最新推荐文章于 2024-10-01 22:51:02 发布
最新推荐文章于 2024-10-01 22:51:02 发布
阅读量96 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45900968/article/details/120067519
版权

④链表

单向链表

链表是有序的列表，但是它在内存中是存储如下
在这里插入图片描述

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

使用带head头的单向链表实现 –水浒英雄排行榜管理
1）完成对英雄人物的增删改查操作， 注: 删除和修改,查找可以考虑学员独立完成，也可带学员完成
2）第一种方法在添加英雄时，直接添加到链表的尾部
3）第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

代码：

//单向链表有序添加
public class SingleLinkedListDemo2 {
	public static void main(String[] args) {
		// 进行测试
		// 先创建节点
		HeroNode hero1 = new HeroNode(1, "宋江1", "及时雨1");
		HeroNode hero3 = new HeroNode(3, "宋江3", "及时雨3");
		HeroNode hero2 = new HeroNode(2, "宋江2", "及时雨2");
		HeroNode hero4 = new HeroNode(4, "宋江4", "及时雨4");
		// 创建要给链表
		SingleLinkedList1 singleLinkedList = new SingleLinkedList1();
		// 加入
		singleLinkedList.add(hero1);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
		singleLinkedList.add(hero4);
		System.out.println("修改前");
		singleLinkedList.list();
		// 测试修改节点的代码
		HeroNode heroNode = new HeroNode(2, "小宋", "123456");
		singleLinkedList.update(heroNode);
		System.out.println("修改后");
		singleLinkedList.list();

		// 删除一个节点
		singleLinkedList.del(1);
		System.out.println("删除后");
		singleLinkedList.list();
	}
}

//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList1 {
	// 先初始化一个头结点，头结点不要动
	private HeroNode head = new HeroNode(0, "", "");

	// 查找单链表中的倒数第k个节点【新浪面试题】
	// 添加节点到单向链表
	// 思路,考虑编号的顺序(如果有这个排名，则添加失败，并给出提示)
	public void add(HeroNode heroNode) {
		// 因为head节点不能动，因此我们仍然需要一个辅助指针temp来帮助找到添加的位置
		// 因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不进去
		HeroNode temp = head;
		boolean flag = false;// 标志添加的编号是否存在，默认为false
		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;// 后移，遍历当前链表
		}
		// 判断flag的值
		if (flag) {// 不能添加，说明编号存在
			System.out.println("准备插入的英雄的编号已经存在" + heroNode.no);
		} else {
			// 插入到链表中，temp的后面
			heroNode.next = temp.next;
			temp.next = heroNode;
		}

	}

	// 修改节点的信息，根据no编号来修改，即no编号不能改
	// 说明
	// 1.根据newHeroNode 的no来修改即可
	public void update(HeroNode heroNode) {
		// 判断是否为空
		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 == heroNode.no) {
				// 找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		// 根据flag判断是否要找到修改的节点
		if (flag) {
			temp.name = heroNode.name;
			temp.nickname = heroNode.nickname;

		} else {
			System.out.println("根本没找到！");
		}
	}

	// 删除节点的代码
	// 思路：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) {// 找到待删除节点的前一个
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.next = temp.next.next;
		} else {
			System.err.println("没找到");
		}
	}

	// 显示链表[遍历]
	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);
			// 将next后移
			temp = temp.next;
		}
	}
}

//定义HeroNode，每个HeroNode对象就是一个节点

class HeroNode {
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;// 指向下一个节点

	// 构造器
	public HeroNode(int hNo, String hName, String hNickname) {
		this.no = hNo;
		this.name = hName;
		this.nickname = hNickname;
	}

	// 为了显示方法，重写toString

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

}

双向链表

使用带head头的双向链表实现 –水浒英雄排行榜
管理单向链表的缺点分析:
1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2）单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会).
3）示意图帮助理解删除

代码：

public class DoubleLinkedListDemo {
	public static void main(String[] args) {
		//测试
		System.out.println("双向链表的测试");
		HeroNode2 hero1 = new HeroNode2(1, "宋江1", "及时雨1");
		HeroNode2 hero3 = new HeroNode2(3, "宋江3", "及时雨3");
		HeroNode2 hero2 = new HeroNode2(2, "宋江2", "及时雨2");
		HeroNode2 hero4 = new HeroNode2(4, "宋江4", "及时雨4");
		
		//创建一个双向链表
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		
		doubleLinkedList.add(hero1);
		doubleLinkedList.add(hero2);
		doubleLinkedList.add(hero3);
		doubleLinkedList.add(hero4);
		
		doubleLinkedList.list();
		
	}
	

}


//创建一个双向链表的类
class DoubleLinkedList{
	//先初始化一个头结点，头结点不要动
	private HeroNode2 head = new HeroNode2(0, "", "");
	
	//返回头结点
	public HeroNode2 getHead() {
		return head;
	}
	
	//添加一个节点到双向链表
	//思路,当不考虑编号的顺序是
	//1.找到当前链表的最后节点
	//2.将最后的这个节点的next指向新的节点
	public void add(HeroNode2 heroNode) {
		//因为head节点不能动，因此我们需要一个辅助遍历temp
		HeroNode2 temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if (temp.next==null) {
				break;
			}
			//如果没有找到最后，temp后移
			temp=temp.next;
		} 
		//当退出while循环时，temp就指向了链表的最后
		//temp.next=heroNode;
		//heroNode.pre=temp;
		temp.next=heroNode;
		heroNode.pre=temp;
	}
	
	//显示链表[遍历]
	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);
			//将next后移
			temp=temp.next;
		}
	}
	//修改节点的信息，根据no编号来修改，即no编号不能改
	//说明
	//1.根据newHeroNode 的no来修改即可
	public void update(HeroNode2 heroNode) {
		//判断是否为空
		if (head.next==null) {
			System.out.println("链表为空");
			return;
		}
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode2 temp = head.next;
		boolean flag = false;//表示是否找到该节点
		while(true) {
			if (temp==null) {
				break;//已经遍历完链表
			}
			if (temp.no==heroNode.no) {
				//找到
				flag=true;
				break;
			}
			temp=temp.next;
		}
		//根据flag判断是否要找到修改的节点
		if (flag) {
			temp.name=heroNode.name;
			temp.nickname=heroNode.nickname;
			
		}else {
			System.out.println("根本没找到！");
			
		}
	}
	//删除节点的代码
	//思路：1.直接找到要删除的节点
	public void del(int no) {
		if (head.next==null) {
			System.out.println("链表为空，无法删除");
		}
		HeroNode2 temp = head.next;
		boolean flag = false;
		while(true) {
			if (temp==null) {//已经最后
				break;
			}
			if (temp.no==no) {//找到待删除节点的前一个
				flag=true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			//temp.next=temp.next.next;
			temp.pre.next=temp.next;
			//这里我们的代码有问题？
			//如果是最后一个节点，就不需要执行下面的这句话
			
			temp.next.pre=temp.pre;
		}
		else {
			System.err.println("没找到");
		}
	}
	
}


//定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode2{
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;//指向下一个节点
	public HeroNode2 pre;//指向前一个节点
	
	//构造器
	public HeroNode2(int hNo,String hName,String hNickname) {
		this.no=hNo;
		this.name=hName;
		this.nickname=hNickname;
	}

	//为了显示方法，重写toString
	@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开始计数，直到最后一个结点从链表中删除算法结束。

在这里插入图片描述

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

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

代码：

public class Josephu {

	public static void main(String[] args) {
		CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);
		circleSingleLinkedList.showBoy();
	}

}

//创建一个环形的单向链表
class CircleSingleLinkedList {
	// 先创建一个first节点
	private Boy first = null;
	// 添加小孩节点，构成一个环形链表

	public void addBoy(int nums) {
		// nums 做一个数据校验
		if (nums < 1) {
			System.out.println("nums不正确！");
			return;
		}
		Boy curBoy = null;// 辅助指针，帮忙构建环形链表
		// 使用for循环创建我们的环形链表
		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.println(curBoy.getNo());
			if (curBoy.getNext() == first) {
				break;
			}
			curBoy = curBoy.getNext();
		}
	}

}

//创建一个boy类，表示一个节点
class Boy {
	private int no;// 编号
	private Boy next;// 指向下一个节点，默认null

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public Boy getNext() {
		return next;
	}

	public void setNext(Boy next) {
		this.next = next;
	}

	public Boy(int no) {
		super();
		this.no = no;

	}

	public Boy() {
		super();
	}

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

}
王惠龙
关注
专栏目录
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
算法与数据结构-综合提升C++版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
java数据结构-链表详解
m0_63526467的博客
05-04 4168
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
Java数据结构与算法——双向链表
★★光亭★★
03-11 6149
Java数据结构与算法——双向链表
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java数据结构与算法——单向链表
★★光亭★★
03-11 5906
Java数据结构与算法——单向链表
数据结构---Java版
qq_63897791的博客
11-24 2553
🎈数据结构通常有四种基本类型：集合结构，线性结构（一对一），树形结构（一对多），图形结构或网状结构（多对多）；主要描述的三个方面的内容：数据的逻辑结构、物理结构、数据的操作集合。🎈数据的逻辑结构与数据在计算机中的具体存储没有关系，主要包括集合、线性、树形、图形结构，有两个要素，数据结构的集合（D）和D上的关系集（反映了D中元素的前驱后继关系）。🎈数据的物理结构又称存储结构，有顺序和链式两种方式：🎶顺序存储的特点是数据元素在存储器中的相对位置来说体现数据元素的逻辑关系，通常用一维数组来实现。
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1414
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
链表-Java实现链表数据结构
♾️
06-08 2632
链表通常由一连串节点组成，每个节点包含任意的实例数据(data fields)和一或两个用来指向上 一个/或下一个节点的位置的链接(“links”) 链表(Linked list)：是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数 据，而是在每一个节点里存到下一个节点的指针(Pointer)。 使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针 域，空间开销比较.
Java数据结构与算法之链表插入操作
m0_43405302的博客
10-29 1897
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、插入元素操作 在介绍插入元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，现在我们想把n3插入其中。这样我们有三种插入方式： class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Li
数据结构-二叉链表的结构与实现
m0_61789994的博客
05-11 8621
二叉链表是一种特殊的链表，它的每个节点都有两个指针，一个指向左子树，一个指向右子树。这种结构可以用来表示树形结构，如二叉树等。二叉链表是一种常用的数据结构，它可以用于实现二叉树、哈夫曼树、二叉堆、二叉搜索树等算法。二叉链表的结构相对简单，实现起来也比较容易，但是需要注意指针的使用，避免出现空指针和死循环等问题。在实际应用中，我们需要根据具体的需求选择合适的数据结构，以提高算法的效率和性能。
数据结构与算法经典问题解析-Java语言描述
08-14
数据结构与算法是计算机科学的基础，对于任何编程语言来说，理解和掌握它们都是至关重要的，特别是对于Java开发者。这本书“数据结构与算法经典问题解析-Java语言描述”旨在帮助读者深入理解这些概念，并通过具体的...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
【高阶数据结构】平衡二叉树(AVL)的删除和调整
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
09-26 974
平衡二叉树节点的删除方法详细讲解；平衡二叉树的删除代码实现(C++);
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 248
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
数据结构-3.10.队列的应用
最新发布
ADCvbV的博客
10-01 194
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1132
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
快速转置算法实现与解析 - Java数据结构
"快速转置算法是用于矩阵转置的一种高效方法，主要应用于Java数据结构中。算法主要包括三个步骤：计算每列非零元素个数、确定非零元素在目标矩阵中的位置，以及扫描源矩阵并按顺序放置元素。算法在处理稀疏矩阵时尤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王惠龙

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

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

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

打赏作者

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

抵扣说明：

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

余额充值