单链表进阶学习 三段
从尾到头打印单链表:
思路:
- 实际意义就是逆序打印单链表;
- 利用栈的操作,先进后出,实现逆序打印效果。
(注:不建议直接对单链表进行反转操作。这样会破坏链表本身的结构,在做题和练习的时候可以尝试,但在工作中考虑到链表的重复使用,最好习惯使用栈数据结构的思想来操作)
演示栈:
- 要单个取出栈元素的操作
import java.util.Stack;
public class TextStackDemo {// 演示栈的操作
public static void main(String[] args) {
// TODO Auto-generated method stub
// 输入“new stack()”,快捷键“ctrl+1”
Stack<String> stack = new Stack<>();// 新建一个stack栈,标注键入String类型的数据
// 入栈
stack.add("1");//可以用push();
stack.add("2");
stack.add("3");
// 键入栈stack三个string类型的数据
// 入栈完成
// 出栈
// pop()直接代表出栈操作
System.out.println(stack.pop());// 一次操作出栈一个数据
}
}
2.将栈元素一次性取出的操作
import java.util.Stack;
public class TextStackDemo {// 演示栈的操作
public static void main(String[] args) {
// TODO Auto-generated method stub
// 输入“new stack()”,快捷键“ctrl+1”
Stack<String> stack = new Stack<>();// 新建一个stack栈,标注键入String类型的数据
// 入栈
stack.add("1");
stack.add("2");
stack.add("3");
// 键入栈stack三个string类型的数据
// 入栈完成
// 出栈
// pop()直接代表出栈操作
while (stack.size() > 0) {
System.out.println(stack.pop());// 一次操作出栈一个数据
}
}
}
接下来进入正题:
用栈的思想解决单链表的逆序打印:
import java.util.Stack;
public class SingleLinkedListDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
第一阶段测试代码
// 创建节点
HeroNode hero1 = new HeroNode(1, "呼保义", "宋江");
HeroNode hero2 = new HeroNode(2, "玉麒麟", "卢俊义");
HeroNode hero3 = new HeroNode(3, "智多星", "吴用");
HeroNode hero4 = new HeroNode(4, "入云龙", "公孙胜");
HeroNode hero5 = new HeroNode(5, "大刀", "关胜");
// 创建单链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);
singleLinkedList.add(hero5);
// 测试单链表逆序功能
// 显示
System.out.println("原链表:");
singleLinkedList.list();
System.out.println();
System.out.println("逆序输出的链表:");
reversePrint(singleLinkedList.GetHead());
/*
* //测试单链表反转功能 // 显示 System.out.println("原链表:"); singleLinkedList.list();
*
* System.out.println(); System.out.println("反转后的链表:");
* reverseList(singleLinkedList.GetHead()); singleLinkedList.list();
*
*
* // 加入操作
*
* // singleLinkedList.add(hero1); // // singleLinkedList.add(hero2); // //
* singleLinkedList.add(hero3); // // singleLinkedList.add(hero4); // //
* singleLinkedList.add(hero5);
*
* singleLinkedList.addByOrder(hero1);
*
* singleLinkedList.addByOrder(hero2);
*
* singleLinkedList.addByOrder(hero4);
*
* singleLinkedList.addByOrder(hero3);
*
* singleLinkedList.addByOrder(hero5);
*
* // 修改操作 HeroNode newHeroNode = new HeroNode(5, "写轮眼", "卡卡西");
* singleLinkedList.update(newHeroNode);
*
* // 显示 System.out.println("删除前:"); singleLinkedList.list();
*
* // 修改操作 singleLinkedList.del(1); System.out.println("删除后:");
* singleLinkedList.list(); // 获取单链表节点的个数
* System.out.println(GetNumber(singleLinkedList.GetHead()));
*
* HeroNode res = findLastIndexNode(singleLinkedList.GetHead(), 1);// 倒数第1个
* System.out.println(); System.out.println("单链表中倒数第index个节点 " + res);
*/
}
// 逆序打印单链表
public static void reversePrint(HeroNode head) {
if (head.next == null) {
return;// 空链表,无法打印
}
// 创建一个栈,将各节点压入栈中
Stack<HeroNode> stack = new Stack<HeroNode>();
HeroNode cur = head.next;// 遍历需要的辅助变量
while (cur != null) {
stack.push(cur);
cur = cur.next;// 后移,好压入下一个节点
}
// 出栈
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
// 反转链表
public static void reverseList(HeroNode head) {
// 老样子,先判断链表是否为空
if (head.next == null || head.next.next == null) {
return;
}
// 定义一个辅助变量,帮助遍历整个链表
HeroNode cur = head.next;
HeroNode next = null;// 指向当前节点【cur】的下一个节点
HeroNode reverseHead = new HeroNode(0, "", "");
// 遍历原来的链表
// 遍历一个节点就将其取出,放在新建链表的最前端
while (cur != null) {
next = cur.next;// 暂时保存当前节点的下一个节点
cur.next = reverseHead.next;// cur节点的下一个节点指向新链表的最前端
reverseHead.next = cur;// 将cur连接到新的链表上
cur = next;// cur后移
}
// 将原链表的头节点的next指向rereverseHead的下一个节点,实现链表的反转
head.next = reverseHead.next;
}
// 1.查找单链表中倒数第index个节点
// 2.编写一个方法接收head节点,同时接受一个index(index数值代表单链表的倒数第index个节点)
// 3.将链表遍历一遍,得到有效节点总数(GetNumber)
// 4.单链表有效节点总数为size,直接遍历size-index个节点
// 5.如果找到了这个节点就返回该节点,否则就返回NULL
public static HeroNode findLastIndexNode(HeroNode head, int index) {
// 如果链表为空返回NULL
if (head.next == null) {
return null;
}
// 第一次遍历得到单链表的节点个数
int size = GetNumber(head);
// 第二次遍历单链表,这次直接遍历size-index个节点,这就是要求的值
// 在这里要做一个index的校验
if (index <= 0 || index > size) {
return null;
}
// 定义一个辅助变量,指向第一个有效节点(头节点后的第一个节点)
HeroNode cur = head.next;
// for循环定位到倒数index个节点
for (int i = 0; i < size - index; i++) {
cur = cur.next;
}
return cur;
}
//获取单链表节点的个数(如果带头结点,计数时要取消头结点的计数,因为头节点不存储数据)
public static int GetNumber(HeroNode head) {
if (head.next == null) {
return 0;
}
int number = 0;
// 定义一个辅助变量
HeroNode cur = head.next;// 这里就是没有统计头结点的微操作
while (cur != null) {
number++;
cur = cur.next;
}
return number;
}
}
//定义一个SingleLinkedList(单链表),管理英雄
class SingleLinkedList {
// 一开始要初始化一个头节点,保持不动否则会找不到剩下的节点,***不存放具体数据
private HeroNode head = new HeroNode(0, "", "");// no初始化为0,姓名和称号也不写
// 返回头节点
public HeroNode GetHead() {
return head;
}
// 添加节点到单向链表
// 当不考虑编号顺序时:
// 把节点添加进去的操作是首先找到当前链表的最后一个节点,next域原本是NULL,要把next域指向新添的节点
public void add(HeroNode heroNode) {
// 由于头节点不能动,所以需要辅助变量
HeroNode temp = head;// temp是辅助变量一开始指向头节点,因为单向链表不是顺序存储,所以每一次找最后一个节点都需要遍历整个链表
// 开始遍历
while (true) {// 死循环
if (temp.next == null) {// 找到链表的尾节点了
break;
}
// 如果当前节点不是末节点
// temp后移一位
temp = temp.next;// 要清楚temp是一个移动辅助变量,每遍历到一个不是尾节点的点temp就会指向当前节点的下一个节点
}
// 当退出这个死循环的时候,temp就指向了单链表的尾节点
// 这个时候就可以把尾节点的next域指向传入的新节点,这个新传入的节点就连上了
temp.next = heroNode;
}
// 增添节点,按照顺序显示出来
// 如果已经有这个编号,则添加失败并给出提示
public void addByOrder(HeroNode heroNode) {// heroNode为传入的新节点
// 由于头节点不能动,所以需要辅助变量
// 单链表要添加节点,temp一定是指向要插入位置的前一个节点,然后temp.next就指向新节点,这样第一步就完成了
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;
} else {
temp = temp.next;// 如果上述情况都不符合的话,那么继续遍历找下一个节点
}
}
// 退出循环的时候要看flag的值
if (flag) {
System.out.printf("已有编号%d,添加失败~~~\n", heroNode.no);
} else {
// 可以插入到链表中,temp后移
heroNode.next = temp.next;// 新节点的next域指向下一个节点
temp.next = heroNode;// 前一个节点的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;
} else if (temp.no == newHeroNode.no) {// 表示已经找到要删除的节点
flag = true;
break;
}
temp = temp.next;
}
// 退出循环以后,根据flag的值来判断
if (flag) {
// flag=true;表示找到了要修改的点
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}
// 还有一种情况就是没有找到要修改的点
else {
System.out.println();
System.out.printf("没有找到编号为%d 的好汉,不能删除😔\n");
}
}
//删除节点
/*
* 1.由于头节点不能动,所以需要辅助变量,需要用辅助变量temp找到待删除节点的前一个节点 比较时使用temp.next.no和待删除节点的编号no比较
*
*/
public void del(int no) {
HeroNode temp = head;// 因为需要找到目标节点的前一个节点,所以这里不能把辅助节点定义为头节点之后第一个节点
boolean flag = false;
while (true) {
if (temp.next == null) {// 到链表最后,最后一个节点的后面
break;
} else if (temp.next.no == no) {// 找到前一个节点
flag = true;
break;
}
temp = temp.next;// 每遍历一个节点就后移一位
}
if (flag) {// 找到了前一个节点
// 删除操作
temp.next = temp.next.next;
} else {
System.out.println();
System.out.printf("删除的数据%d不存在呀不存在~~~\n", 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);// 因为之前已经重写过toString方法了,所以这里直接打印输出就行了
// ************
// 下面这点很重要,每打印输出一个节点,就需要将辅助变量temp后移,否则的话后果就是一直输出一个值而且是个死循环
temp = temp.next;
}
}
}
//定义HeroNode,每个HeroNode都是一个节点
class HeroNode {
public int no;// 定义编号
public String name;// 定义姓名
public String nickname;// 定义称号
public HeroNode next;// 定义next域,指向下一个节点
// 建一个构造器
public HeroNode(int no, String nickname, String name) {
this.no = no;
this.nickname = nickname;
this.name = name;
}
// 为了便于显示,重写toString方法
/*
* @Override是伪代码,表示重写。(当然不写@Override也可以),不过写上有如下好处: 1、可以当注释用,方便阅读;
* 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错。
* 例如,你如果没写@Override,而你下面的方法名又写错了,这时你的编译器是可以编译通 过的,因为编译器以为这个方法是你的子类中自己增加的方法。
*/
@Override
public String toString() {
return "no= " + no + ",nickname= " + nickname + ",name = " + name;
}
}
合并两个单链表,依照顺序打印输出:
思路:
- 创建一个新的单链表;
- 依次遍历两个原来的单链表,每遍历一次取出一个最小的节点接到新链表之后。
public class LinkedListConbine {
public static void main(String[] args) {
SingleLinkedList4 singleLinkedList1 = new SingleLinkedList4();
SingleLinkedList4 singleLinkedList2 = new SingleLinkedList4();
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(3);
Node node4 = new Node(4);
Node node5 = new Node(5);
Node node6 = new Node(6);
Node node7 = new Node(7);
Node node8 = new Node(8);
singleLinkedList1.add(node3);
singleLinkedList1.add(node1);
singleLinkedList1.add(node7);
singleLinkedList1.add(node5);
singleLinkedList2.add(node2);
singleLinkedList2.add(node6);
singleLinkedList2.add(node8);
singleLinkedList2.add(node4);
System.out.println("链表一:");
singleLinkedList1.show(singleLinkedList1.head);
System.out.println("链表二:");
singleLinkedList2.show(singleLinkedList2.head);
System.out.println("合并两个链表==========");
Node conbine = singleLinkedList1.conbine(singleLinkedList1.head, singleLinkedList2.head);
singleLinkedList1.show(conbine);
}
}
class SingleLinkedList4 {
public Node head;
public SingleLinkedList4() {
head = new Node(-1);
}
/**
* 数据按从小到大的顺序添加到链表中
* @param newNode 新节点
*/
public void add(Node newNode) {
//辅助变量必须从head开始,不能从head.next开始,否则链表就断了
Node cur = head;
Node pre = head;
int value = newNode.num;
while (cur.next != null) {
pre = cur;
cur = cur.next;
if(value <= cur.num) { //小于节点cur,插在cur前面
newNode.next = cur;
pre.next = newNode;
return; //当前链表中存在大于等于value的值
}
}
cur.next = newNode; //当前链表中不存在大于等于value的值,则添加到末尾
}
public void show(Node head) {
Node cur = head.next;
if (cur == null) {
System.out.println("链表为空~");
}
while (cur != null) {
System.out.println(cur);
cur = cur.next;
}
}
public Node conbine(Node head1, Node head2) {
Node conbine = new Node(-1);
Node conbineTemp = conbine;
Node cur1 = head1.next;
Node cur2 = head2.next;
while (cur1 != null && cur2 != null) {
if (cur1.num <= cur2.num) {
conbineTemp.next = new Node(cur1.num);
conbineTemp = conbineTemp.next;
cur1 = cur1.next;
} else {
conbineTemp.next = new Node(cur2.num);
conbineTemp = conbineTemp.next;
cur2 = cur2.next;
}
}
if (cur1 == null) {
while (cur2 != null) {
conbineTemp.next = new Node(cur2.num);
conbineTemp = conbineTemp.next;
cur2 = cur2.next;
}
} else {
while (cur1 != null) {
conbineTemp.next = new Node(cur1.num);
conbineTemp = conbineTemp.next;
cur1 = cur1.next;
}
}
return conbine;
}
}