1、链表介绍
链表是有序的列表，但是它在内存中是存储如下
✨ 小结上图：
- 链表是以节点的方式来存储，
是链式存储 - 每个节点包含 data 域、next 域：指向下一个节点
- 如图：发现
链表的各个节点不一定是连续存储 - 链表分
带头结点的链表和不带头结点的链表，根据实际需求来确定
🎐 单链表（带头结点）逻辑结构示意图如下：
2、单链表的应用实例
使用带 head 头的单向单链表实现 - 水浒英雄排行榜管理完成对英雄的增删改查操作
- 第一种方法在添加英雄时，直接添加到链表的尾部
思路分析示意图：
- 第二种方式再添加英雄时，
根据排名将英雄插入到指定位置（如果有这个排名，就添加失败，并给出提示）
思路分析示意图：
-
修改节点功能
先根据第一种思路找到该节点，然后 temp.name = newHeroNode.name , temp.nickName = newHeroNode.nickName -
删除节点
思路分析示意图：
💻 代码演示：
- HeoNode 节点
/**
* 定义 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;
}
//为了显示方便重写 toString
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
- SingleLinkedList
/**
* 定义 SingleLinkedList 管理 HeroNode 节点
*/
class SingleLinkedList{
/**
* 初始化一个 HeroNode 头结点，头结点不要动，不存放具体的值
*/
private HeroNode head = new HeroNode(0,"","");
/**
* 获取头结点
*/
public HeroNode getHead(){
return head;
}
/**
* 添加节点到单向链表中
*/
public void addHeroNode(HeroNode heroNode){
//首先要找到该单向链表的尾部
HeroNode temp = head;
while (temp.next != null) {
//如果没有找到链表最后
temp = temp.next;
}
//将尾部的next域指向新的节点
temp.next = heroNode;
}
/**
* 根据节点编号将节点插入到链表中
*/
public void addHeroNodeByNo(HeroNode heroNode){
HeroNode temp = head;
boolean flag = 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.printf("待插入的节点编号【%d】已存在\n",heroNode.no);
}else{
heroNode.next = temp.next;
temp.next = heroNode;
}
}
/**
* 根据编号修改节点信息
*/
public void updateNode(HeroNode newHeroNode){
if (head.next == null){
return;
}
//声明辅助变量
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp.next == 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.printf("未找到编号为【%d】的节点\n",newHeroNode.no);
}
}
/**
* 根据节点编号删除节点
*/
public void deleteNode(int no){
if (head.next == null){
return;
}
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.out.printf("没有查找到编号为【%d】的节点",no);
}
}
/**
* 显示链表
*/
public void list(){
//判断链表为空
if (head.next == null){
return;
}
//需要辅助变量
HeroNode temp = head;
while (true){
//是否到链表最后
if (temp.next == null){
break;
}
//输出节点信息
System.out.println(temp.next);
//后移temp
temp = temp.next;
}
}
}
- 测试
public static void main(String[] args) {
HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.addHeroNode(heroNode1);
singleLinkedList.addHeroNode(heroNode4);
singleLinkedList.addHeroNode(heroNode2);
singleLinkedList.addHeroNode(heroNode3);
singleLinkedList.list();
System.out.println("更新后的节点....");
HeroNode heroNode = new HeroNode(2, "小卢", "玉麒麟~~~");
singleLinkedList.updateNode(heroNode);
singleLinkedList.list();
System.out.println("删除节点....");
singleLinkedList.deleteNode(3);
singleLinkedList.list();
3、单链表面试题（新浪、百度、腾讯）
单链表的常见面试题如下：
📞 求单链表中有效节点的个数
分析： 获取到单链表中的节点个数（如果是带有头结点的链表，需求不统计头结点）
💻 代码实现
public int getLength(HeroNode head){
if (head.next == null){
return 0;
}
HeroNode temp = head;
int count = 0;
while (temp.next != null){
count ++;
temp = temp.next;
}
return count;
}
📞 查找单链表中的倒数第 k 个节点
分析：
- 编写一个方法，接收 head 节点，同时接收一个 index 表示倒数第几个节点
- 统计出链表中有效元素个数
- 对链表进行遍历，if((count+1)-index == tmp.next.no) 就表示找到了该节点，否则未找到，返回null
💻 代码实现
/**
* 查找单链表中倒数第 K 个节点信息【新浪面试题】
*/
public HeroNode findLatIndexNode(HeroNode head, int index){
//获取链表中有效元素的个数
if (head.next == null){
return null;
}
HeroNode temp = head;
boolean flag = true;
int count = 0;
while (temp.next != null){
count ++;
temp = temp.next;
}
HeroNode tmp = head;
//遍历查找根据index
while (flag){
if (tmp.next == null){
return null;
}
if ((count+1)-index == tmp.next.no){
flag = false;
return tmp.next;
}
tmp = tmp.next;
}
return null;
}
📞 单链表的反转
分析：
- 先定义一个节点 reverseHead = new HeroNode();
- 从头到尾遍历原来的链表，每遍历一个节点，将其取出，放在新的链表 reverseHead 的最前端
- 原来链表的 head.next = reverseHead.next
- 分析示意图
💻 代码实现
/**
* 将单链表进行反转
*/
public void reverseLinkedList(HeroNode head){
//如果当前链表为空或只有一个节点无需进行反转,直接返回
if (head.next == null || head.next.next == null){
return;
}
//定义一个辅助指针，帮助我们遍历原来的链表
HeroNode temp = head.next;
//指向当前节点的下一个节点
HeroNode next = null;
HeroNode reverseHead = new HeroNode(0,"","");
while (temp != null){
next = temp.next; //先暂时保存当前节点的下一个节点，因为后面需要
temp.next = reverseHead.next; //将当前节点的下一个节点指向新的链表的最前端
reverseHead.next = temp; //将temp 连接到新的链表上
temp = next; //将 head.next 指向 reverseHead.next ，实现单链表的反转
}
//将原先头结点指向现在的节点
head.next = reverseHead.next;
}
📞 从尾到头打印单链表【要求方式1：反向遍历，方式2：Stack 栈】
分析：
- 方式一：现将单链表进行反转操作，然后再遍历即可。但是这样会破会单链表原有的结构，【不建议】
- 方式二：可以使用
栈这个数据结构，将每个节点压入栈中，使用栈的先进后出的原则，实现逆序输出。
💻 代码实现
/**
* 从尾到头打印单链表（反向遍历）
* 使用栈数据结构反向遍历链表
*/
public void reverseErgodic(HeroNode head){
if (head.next == null){
System.out.println("链表为空....");
}
Stack<HeroNode> stack = new Stack<>();
HeroNode temp = head.next;
while (temp != null){
stack.push(temp);
temp = temp.next;
}
//遍历栈中元素
while (stack.size() > 0){
System.out.println(stack.pop());
}
}
📞 合并两个有序的单链表，合并之后的链表依然有序
分析：
- 利用第三个单链表存储两个单链表的节点，
- 若两个链表均为空，则直接返回；若其中一个链表为空，则直接将另一个链表连接至链表3上；
- 若两个链表均不为空，先将其中一个链表1连接至链表3，然后遍历另一个链表2，将链表2中的节点按照顺序连接至链表3上。
- 若出现链表3遍历完毕但链表2尚未遍历完毕的情况，可以直接将链表2剩下的节点连接至链表3尾部。
💻 代码实现
/**
* 合并两个有序的单链表，合并完之后依然有序
* @param head1 有序单链表一
* @param head2 有序单链表二
* @param head3 合并之后的有序链表
*/
public static void mergeLinkedList(HeroNode head1, HeroNode head2, HeroNode head3){
if (head1.next == null && head2.next == null){
return;
}
if (head1.next == null){
head3.next = head2.next;
}else if (head2.next == null){
head3.next = head1.next;
}else {
//将链表1,复制给目标链表
head3.next = head1.next;
//定义一个辅助指针，由于遍历链表2
HeroNode temp = head2.next;
//定义一个辅助指针，由于遍历链表3
HeroNode cur = head3;
HeroNode next = null;
while (temp != null){
//如果目标链表遍历完毕，可以直接将链表二追加在后面
if (cur.next == null){
cur.next = temp;
break;
}
if (cur.next.no >= temp.no){
next = temp.next;
temp.next = cur.next;
cur.next = temp;
temp = next;
}
cur = cur.next;
}
}
}
4、双向连链表的应用实例
- 双向链表的操作分析与实现
使用带 head 头节点的双向链表实现 水浒英雄排行榜
🎃 管理单向链表的缺点分析：
- 单向链表，查找的方向只能是一个方向，而双向链表可以向前或向后查找
- 单向链表不能自我删除，需要依靠辅助指针，而双向链表，则可以实现自我删除
- 分析双向链表如何完成遍历、添加、修改、删除思路
对上图说明：
- 遍历方式和单链表一样
- 添加 （默认添加到双线链表的最后）
🎋 先找到双向链表最后这个节点
🎋 temp.next = newHeroNode
🎋 newHeroNode.pre = temp - 修改思路和原来单链表一样
- 删除
🎋 因为是双向链表，因此。我们可以实现自我实现删除某个节点
🎋 直接找到要删除的节点，比如 temp
🎋 temp.pre.next = temp.next
🎋 temp.next.pre = temp.pre
💻 代码实现
package com.yao.linkedList;
public class DoubleLinkedListDemo {
public static void main(String[] args) {
System.out.println("双向链表的测试.....");
HeroNode2 heroNode1 = new HeroNode2(1, "宋江", "及时雨");
HeroNode2 heroNode2 = new HeroNode2(2, "卢俊义", "玉麒麟");
HeroNode2 heroNode3 = new HeroNode2(3, "吴用", "智多星");
HeroNode2 heroNode4 = new HeroNode2(4, "林冲", "豹子头");
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
doubleLinkedList.addNodeByNo(heroNode4);
doubleLinkedList.addNodeByNo(heroNode1);
doubleLinkedList.addNodeByNo(heroNode2);
doubleLinkedList.addNodeByNo(heroNode3);
doubleLinkedList.getList();
System.out.println("修改节点信息...");
HeroNode2 newNode = new HeroNode2(4, "小林", "豹子头~~~");
doubleLinkedList.updateNode(newNode);
doubleLinkedList.getList();
System.out.println("删除节点信息...");
doubleLinkedList.deleteNode(3);
doubleLinkedList.getList();
}
}
/**
* 创建一个双向链表的类
*/
class DoubleLinkedList{
//头结点
private final HeroNode2 head = new HeroNode2(0,"","");
//获取头结点
private HeroNode2 getHead(){
return head;
}
/**
* 遍历双向链表
*/
public void getList(){
if (head.next == null){
return;
}
HeroNode2 temp = head;
while (temp.next != null) {
System.out.println(temp.next);
temp = temp.next;
}
}
/**
* 向双向链表中添加节点（默认向链表末尾添加）
*/
public void addNode(HeroNode2 newHeroNode2){
HeroNode2 temp = head;
while (temp.next != null) {
temp = temp.next;
}
//形成一个双向节点
temp.next = newHeroNode2;
newHeroNode2.pre = temp;
}
/**
* 根据节点编号向双向链表中添加节点
*/
public void addNodeByNo(HeroNode2 newHeroNode){
HeroNode2 temp = head;
boolean flag = false;
while (true){
if (temp.next == null){
break;
}
if (temp.next.no > newHeroNode.no){
break;
}else if (temp.next.no == newHeroNode.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
System.out.println("待插入的节点已存在....");
}else {
if (temp.next == null){
temp.next = newHeroNode;
newHeroNode.pre = temp;
}else {
newHeroNode.next = temp.next;
newHeroNode.next.pre = newHeroNode;
newHeroNode.pre = temp;
temp.next = newHeroNode;
}
}
}
/**
* 修改一个节点的信息
*/
public void updateNode(HeroNode2 heroNode2){
if (head.next == null){
return;
}
HeroNode2 temp = head.next;
boolean flag = false;
while (true){
if (temp == null){
break;
}
if (temp.no == heroNode2.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = heroNode2.name;
temp.nickName = heroNode2.nickName;
}else {
System.out.printf("未找到编号为【%d】的节点\n",heroNode2.no);
}
}
/**
* 删除双向链表的节点
*/
public void deleteNode(int number){
if (head.next == null){
return;
}
HeroNode2 temp = head.next;
boolean flag = false;
while (true){
if (temp == null){
break;
}
//对于双向链表找到后直接删除基础即可，无需像单链表要找到待删除的前一个节点
if (temp.no == number){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.pre.next = temp.next;
//如果要删除的节点是最后一个节点，不需要执行下面的语句
if (temp.next != null){
temp.next.pre = temp.pre;
}
}else {
System.out.printf("未找到编号为【%d】的节点",number);
}
}
}
/**
* 定义 HeroNode 每个 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;
}
//为了显示方便重写 toString
@Override
public String toString() {
return "HeroNode2{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName +"}";
}
}
5、单向环形链表应用场景
- Josephu(约瑟夫、约瑟夫环)问题
Josephu问题为: 设编号为1, 2, … n的n个人围坐一圈，约定编号为k (1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
提示:用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
- 单向环形链表介绍
- Josephu 问题
🎆 约瑟夫问题示意图
- 约瑟夫问题-创建环形队列的思路图解
- 约瑟夫问题-小孩出圈的思路图解
💻 代码实现
package com.yao.linkedList;
/**
* 约瑟夫环问题
*/
public class Josepfu {
public static void main(String[] args) {
//测试
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.addNode(5); // 加入5个节点的小孩
circleSingleLinkedList.list();
System.out.println("出圈");
circleSingleLinkedList.countBoy(1, 2, 5);
}
}
/**
* 创建一个单项环形链表
*/
class CircleSingleLinkedList{
//添加一个 first 节点
private Boy first = new Boy(-1);
//添加节点，构建环形链表
public void addNode(int nums){
//对 nums 进行校验
if (nums < 1){
return;
}
Boy curBoy = null; //辅助指针，帮助构建环形链表
//使用for循环来创建我们的环形链表
for (int i = 1; i <= nums; i++) {
//根据编号，创建小孩节点
Boy boy = new Boy(i);
//如果是第一小孩
if (i == 1){
first = boy;
first.next = first; //构成环形
curBoy = first;
}else {
curBoy.next = boy;
boy.next = first;
curBoy = boy;
}
}
}
/**
* 遍历当前环形链表
*/
public void list(){
//判断链表是否为空
if (first == null){
System.out.println("链表为空....");
return;
}
//因为 first不能动，使用辅助指针完成遍历
Boy curBoy = first;
while (true){
System.out.printf("小孩的编号【%d】\n",curBoy.getNo());
if (curBoy.next == first){ //说明已经遍历完毕
break;
}
curBoy = curBoy.next;
}
}
/**
*
* @param startNo 从哪一个小孩开始数数
* @param countNo 表示数几下
* @param numbers 表示最初有多少个孩子在圈中
*/
public void countBoy(int startNo, int countNo, int numbers){
//判断合理性
if(first == null || startNo < 1 || startNo > numbers ){
System.out.println("输入参数有误.....");
return;
}
//创建辅助指针，帮助小孩出圈
Boy helper = first;
while (true){
if (helper.next == first){ //说明helper指向最后节点
break;
}
helper = helper.next;
}
//小孩报数前，先让 first 和 helper 移动 startNo - 1 次
for (int i = 0; i < startNo - 1; i++) {
first = first.next;
helper = helper.next;
}
//当小孩报数时，让 first 和 helper 移动 countNo - 1 次，然后出圈
//循环操作，直到圈中只有一个节点
//说明只剩下一个节点
while (helper != first) {
//移动 first 和 helper
for (int i = 0; i < countNo - 1; i++) {
first = first.next;
helper = helper.next;
}
//此时 first 指向的节点，就是要出圈的节点
System.out.printf("小孩【%d】出圈\n", first.getNo());
first = first.next;
helper.next = first;
}
System.out.printf("最后留在圈中的小孩编号【%d】\n",first.getNo());
}
}
/**
* 创建一个 Boy 类，表示一个节点
*/
class Boy{
public int no;
public Boy next;
public Boy(int no){
this.no = no;
}
//getter和Setter 方法
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;
}
}
🔔 完结
扫一扫
418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
