单链表进阶学习 二段
单链表的反转
思路:
- 定义一个新节点,reserveHead=new HeroNode();
- 利用辅助变量cur遍历原来的链表,每遍历一个节点就将其取出,放在新建链表的最前端;(这里可能理解上有些难度,举一个简单的例子: 首先遍历到原来链表第一个节点,取出,接到新节点reserveHead的后面;接着遍历到原来链表的第二个节点,取出,这个时候把reserveHead的next域指向到新取出的节点
(这里就是原来链表的第二个节点)
,新取出节点的next域指向前一个取出的节点(这里就是原来链表的第二个节点)
;这样就构成了拥有两个有效节点的单链表的反转。如果一个单链表里有更多的节点,就按照上述的思路递归重复) - 把原来链表的头节点指向新链表的第一个节点head.next=reserveHead.next;
(注:
反转意味着要将原链表破坏,在原链表的基础上打印逆序的链表;而不是新建一个链表,把原来的节点直接取出来接在新链表头的后面直接打印出来。这就是上面第三步思路存在的必要性!!!)
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("反转后的链表:");
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 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();
System.out.printf("%-6s",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;
}
}