相声讲究说学逗唱
链表讲究增删改查
上一篇blog里演示了单链表的增加节点的操作，下面演示单链表的删除、修改和查找的操作。
修改操作：
思路：
- 遍历找到待修改节点
- 这里编号no不改变，把称号和姓名重新赋值
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);
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero5);
// 显示
System.out.println("修改前：");
singleLinkedList.list();
HeroNode newHeroNode=new HeroNode(5, "写轮眼", "卡卡西");
singleLinkedList.update(newHeroNode);
System.out.println("修改后：");
singleLinkedList.list();
}
}
//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写
// 添加节点到单向链表
// 当不考虑编号顺序时：
// 把节点添加进去的操作是首先找到当前链表的最后一个节点，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");
}
}
// 显示单向链表
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;
}
}
删除操作：
思想：
- 搜索找到要删除节点的前一个节点；
- temp.next=temp.next.next;（待删除节点前一个节点的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);
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();
}
}
//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写
// 添加节点到单向链表
// 当不考虑编号顺序时：
// 把节点添加进去的操作是首先找到当前链表的最后一个节点，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;
}
}
查找操作：贯穿再上述两个操作之中，本质就是遍历这个单链表，直到找到这个待查找的节点
未完待续。。。。
1782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
