3.4双向链表实例
双向链表，在单向链表的基础上，每个节点都有一个pre属性，指向该节点的前一个元素。使用双向链表实现英雄排行榜
对于英雄节点类，增加pre属性:
package com.kevin.singleListDemo;
/**
* @author : kevin ding
* @date : 2022/2/27 8:36
* @description : 用于双向链表的英雄节点类
*/
public class HeroNode2 {
public int no;
public String name;
public String nickName;
public HeroNode2 next;
public HeroNode2 pre;
// 构造器
public HeroNode2(){
}
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 + '\'' +
'}';
}
}
双向链表实现增删改查的思路：
-
增加节点：
- 在链表的末尾增加：临时指针变量，指向到末尾节点时，将新的节点添加到末尾，同时需要将新加节点的
pre指向当前的末尾节点:
tempNode.next = newHeroNode;newHerNode.pre = tempNode;- **按照指定的顺序增加：**临时变量找到正确的带插入位置的前一个节点，将新的节点插入进去，同时需要将
pre指针指向正确的位置：
// 插入到tempNode的后面即可 heroNode.next = tempNode.next; tempNode.next = heroNode; // 添加pre的指针指向 if(heroNode.next != null){ heroNode.next.pre = heroNode; } heroNode.pre = tempNode; - 在链表的末尾增加：临时指针变量，指向到末尾节点时，将新的节点添加到末尾，同时需要将新加节点的
-
修改节点：与单向链表无异，直接找到待修改的节点，修改节点的其他属性内容即可
-
查询所有：与单向链表无异
-
删除节点：因为每个节点都有一个next指向后一个节点，一个
pre指向前一个节点，所以，双向链表可以进行自我删除，无需找到待删除节点的前一个节点。//进行删除操作。 tempNode.pre.next = tempNode.next; // 判断节点是否为最后一个,如果不是最后一个，则需要将后一个节点的pre指针指向前一个 if(tempNode.next != null){ tempNode.next.pre = tempNode.pre; }
小结:在进行插入和删除操作时，涉及到需要定义后一个节点的pre指向，所以在进行指向的时候，需要先判断当前的节点是否为最后一个节点，避免出现空指针异常。
代码实现：
package com.kevin.singleListDemo;
/**
* @author : kevin ding
* @date : 2022/2/27 8:45
* @description : 双向链表类
*/
public class TwoPointLinkedList {
// 首先给链表初始化一个头结点
public HeroNode2 headNode = new HeroNode2();
// 方法 addNode 添加节点：(默认往队尾添加)
// 对于给定的节点，找到链表的队尾，将给定的节点插入到末尾，并将新节点的pre指针指向tempNode
public void addNode(HeroNode2 heroNode){
// 因为头结点headNode不能移动，需要一个辅助节点(默认初始指向头结点)进行移动，找到最后一个节点
HeroNode2 tempNode = headNode;
// 开始遍历链表找到链表的最后一个节点
while (true){
if(tempNode.next == null){
break;
}
tempNode = tempNode.next;
}
// 退出循环时，tempNode指向最后一个节点.让其next指向新加的heroNode即可,heroNode的pre指向当前节点
tempNode.next = heroNode;
heroNode.pre = tempNode;
}
// 方法 按照节点编号进行添加，当该节点存在时，提示添加失败
public void addNodeByOrder(HeroNode2 heroNode){
// 因为头结点不能动，所以需要定义临时节点变量，来移动
HeroNode2 tempNode = headNode;
// 定义一个标记变量，来判断当前节点的no是否存在于链表中，默认false。如果存在则添加失败
boolean flag = false;
// 开始进行遍历
while (true){
// 如果遍历到最后，则直接返回
if(tempNode.next == null){
break;
}
// 如果当前节点的下一个节点的no值大于待插入的节点，则找到了正确的位置
if(tempNode.next.no > heroNode.no){
break;
}else if(tempNode.next.no == heroNode.no){
// 如果相等，表示当前节点编号已经存在于链表中,将标记位置为true
flag = true;
break;
}
tempNode = tempNode.next;
}
// 循环结束，此时temp节点的下一个即为带插入的位置
// 当flag为true时不能插入
if(flag){
System.out.println("当前节点"+ tempNode.no+ "已经存在，不能重复添加......");
}else {
// 插入到tempNode的后面即可
heroNode.next = tempNode.next;
tempNode.next = heroNode;
// 添加pre的指针指向
if(heroNode.next != null){
heroNode.next.pre = heroNode;
}
heroNode.pre = tempNode;
}
}
// 遍历链表的所有节点：
public void showAllNodes(){
// 首先判断链表是否为空，如果为空直接返回
if(headNode.next == null){
System.out.println("链表为空......");
return;
}
// 头结点不能动，需要指定一个辅助节点，因为已经判断过head。next不为空，则初始指向头结点的next，即第一个元素
HeroNode2 tempNode = headNode.next;
// 循环遍历所有节点，并显示即可
while (true){
// 每次针对当前节点判断其是否为空即可
if(tempNode == null){
break;
}
// 当前节点不为空，将其打印出来，并将指针后移
System.out.println("当前节点的英雄为：" + tempNode);
tempNode = tempNode.next;
}
}
// 修改列表中指定节点的值
public void updateNode(HeroNode2 heroNode){
// 首先判断链表是否为空
if(headNode.next == null){
System.out.println("链表为空......");
return;
}
// 定义一个临时节点，指向第一个节点元素
HeroNode2 tempNode = headNode.next;
// 遍历找到节点
boolean flag = false;
while (true){
if(tempNode == null){
break;
}
if(tempNode.no == heroNode.no){
flag = true;
break;
}
// 千万不能忘记将节点后移
tempNode = tempNode.next;
}
if(flag){
// 表示找到了该节点，进行更新操作
tempNode.name = heroNode.name;
tempNode.nickName = heroNode.nickName;
}else {
// 链表中没有指定的节点
System.out.println("链表中没有指定的节点：" + heroNode.no);
}
}
// 删除指定编号的节点 双向链表可以直接进行自我删除，无需找到链表的前一个节点元素
public void deleteNode(int no){
// 首先判断节点是否为空
if(headNode.next == null){
System.out.println("链表为空......");
return;
}
// 头结点不能动，需要定义临时节点，找到待删除节点的前一个节点
HeroNode2 tempNode = headNode;
boolean flag = false;
while(true){
if(tempNode == null){
// 遍历到了链表我的最后一个位置
break;
}
// 直接使得tempNode即为待删除的节点
if(tempNode.no == no){
// 找到了待删除的节点
flag = true;
break;
}
tempNode = tempNode.next;
}
// 退出循环后，判断是否找到
if(flag){
//进行删除操作。
tempNode.pre.next = tempNode.next;
// 判断节点是否为最后一个,如果不是最后一个，则需要将后一个节点的pre指针指向前一个
if(tempNode.next != null){
tempNode.next.pre = tempNode.pre;
}
}else {
// 没有找到待删除的节点
System.out.println("没有找到待删除的节点：" + no);
}
}
}
3.5 单向循环链表
3.5.1 概念
单向循环链表：顾名思义，即可以链表的循环，最后一个节点的next指针指向了第一个节点，首位相连形成了一个环状。
应用场景: 约瑟夫问题（Josephu）
3.5.2 约瑟夫问题
设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
实现思路：用一个不带头结点的循环链表来处理：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
-
创建
BoyNode类来用于实现循环链表：package com.kevin.circleSingleLinkedListDemo; /** * @author : kevin ding * @date : 2022/2/27 9:12 * @description : 创建一个孩子节点类，处理约瑟夫环问题 */ public class BoyNode { private int no; private BoyNode next; public BoyNode() { } public BoyNode(int no) { this.no = no; } public int getNo() { return no; } public void setNo(int no) { this.no = no; } public BoyNode getNext() { return next; } public void setNext(BoyNode next) { this.next = next; } } -
循环链表的创建
-
在创建循环链表的时候，首先初始化
firstNode表示链表的第一个节点，初始化指向为null； -
定义临时节点
tempNode，始终使其指向最后一个节点，新的节点直接加入到tempNode的后面 -
同时对于新加入的节点，需要使得当新加入的节点的next指向第一个节点，即形成一个环形
// 初始化 单向循环链表的第一个节点，没有指向任何编号
private BoyNode firstNode = null;
// 构造一个环形链表,添加指定个数元素的环形链表
public void addBoyNode(int nums){
// 1. 首先需要对输入的数字进行校验：
if(nums < 1){
System.out.println("需要创建环形链表中节点个数输入不合理......");
return;
}
// 2. 需要使用一个辅助指针来指向当前节点的最后位置
BoyNode curNode = null;
// 3. 循环创建出节点并添加到环形链表中
for(int i = 1; i <= nums; i++){
BoyNode boyNode = new BoyNode(i);
// 如果为在环中添加的第一个元素：
if (i == 1){
firstNode = boyNode;
firstNode.setNext(firstNode); // 最后一个元素的next指向firstNode节点
curNode = firstNode; // 始终使得curNode指向最后节点
}else {
// 当前节点的next指向待新加如的节点，新加入的节点的next指向firstNode
curNode.setNext(boyNode);
boyNode.setNext(firstNode);
// 随后将curNode指向最新的尾结点
curNode = boyNode;
}
}
}
- 处理约瑟夫问题
- 首先进行边界条件判断，链表是否为空，数据输入是否合理
- 使得第一个节点指向待移除的节点，定义辅助指针初始化指向待删除的前一个节点（属于单向链表，删除时需要找到前一个节点）
- 从第k个节点开始报数，当前指向的是第1个节点，则需要先将两个指针同时移动k-1次
- 从1开始报数，报数到m，第m个出圈，则需移动m-1下，让当前指针指向第m个节点，该节点出圈，辅助指针指向的是待删除节点的前一个
- 循环上面报数删除步骤，直至链表元素为空
/**
*
* @param startNo 表示从第几个节点开始计数（k）
* @param countNum 表示计数多少（m）
* @param nums 表示环形链表节点个数（n）
*/
public void countBoyNode(int startNo, int countNum, int nums){
// 1. 首先判断链表是否为空
if(firstNode == null){
System.out.println("链表为空......");
return;
}
// 2. 对数据进行校验：1<startNo<=nums
if(startNo<1 || startNo>nums){
System.out.println("参数输入有误......");
return;
}
// 3. 定义辅助指针完成遍历和指定节点的出圈,需要让该辅助节点指向最后一个节点，
// 链表节点删除，需要找到删除位置的前一个节点，因此让firstNode指向待删除节点，辅助节点指向前一个
BoyNode helperNode = firstNode;
while(true){
// 当helperNode的next指向第一个节点，说明已经到了最后
if(helperNode.getNext() == firstNode){
break;
}
// 否则 helperNode后移
helperNode = helperNode.getNext();
}
// 4. 从第 k个节点开始报数，则需要将firstNode和helperNode同时后移 k-1步（firstNode已经在第一个节点处）
for(int i = 1; i <startNo ; i++){
// 两个指针同时后移
firstNode = firstNode.getNext();
helperNode = helperNode.getNext();
}
// 5. 开始报数，firstNode从1开始，报数到m，第m个出圈，则需移动m-1下，让firstNode指向第m个节点，该节点出圈
// 此步骤为循环操作，直至所有节点均出圈为止
while (true){
// 当圈中只剩最后一个节点的时候，停止循环
if(helperNode == firstNode){
break;
}
// 开始移动 m-1次
for(int j = 0; j < countNum-1; j++){
firstNode = firstNode.getNext();
helperNode = helperNode.getNext();
}
// 移动m-1次之后，当前first节点指向第m个，为待删除的节点： 先将其打印出来，再删除
System.out.println("出圈的节点为:" + firstNode.getNo());
// 首先将first后移一位，随后将helperNode的next节点指向firstNode
firstNode = firstNode.getNext();
helperNode.setNext(firstNode);
}
// 遍历结束，需要将留在圈中的最后一个节点输出
System.out.println("最后留在循环链表中的节点为：" + helperNode.getNo());
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
