本文深入讲解链表数据结构，包括单链表的实现与管理，英雄排行榜管理应用实例，节点的增删改查操作，以及如何根据排名插入节点，确保链表的有序性。
链表（Linked List）介绍
链表是有序的列表，它在内存中存储如下：
小结：
- 链表是以节点的方式来存储。
- 每个节点包含data域，next域：指向下一个节点。
- 如图：发现链表的各个节点不一定是连续存储。
- 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
单链表（带头节点）结构示意图如下
单链表的应用实例
使用带head头的单向链表实现——水浒英雄排行榜管理
- 完成对英雄人物的增删改查操作，注：删除和修改,查找可以考虑学员独立完成，也可带学员完成。
- 第一种方法在添加英雄时，直接添加到链表的尾部。
- 第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）。
添加节点，直接添加到链表的尾部
实现思路：第一种方法在添加英雄时，直接添加到链表的尾部。
代码示例
package test;
public class LinkedList {
public static void main(String[] args){
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingLinkedList singLinkedList = new SingLinkedList();
// 加入
singLinkedList.add(hero3);
singLinkedList.add(hero1);
singLinkedList.add(hero4);
singLinkedList.add(hero2);
// 显示
singLinkedList.list();
}
}
// 定义SingLinkedList 管理我们的英雄
class SingLinkedList{
// 先初始化一份头节点，头结点不能动，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 思路：当不考虑编号顺序时
// 1、找到当前链表的最后节点
// 2、将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
// 因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
// 遍历链表，找到最后
while (true){
// 找到链表的最后
if (temp.next == null){
break;
}
// 如果没有找到最后，将temp后移
temp = temp.next;
}
// 当退出循环是，temp就指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = heroNode;
}
// 显示遍历链表
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);
// 输出节点后一定要将temp后移，一定小心
temp = temp.next;
}
}
}
// 定义一个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 + '\'' +
'}';
}
}
添加节点，根据排名将英雄插入到指定位置
实现思路：第二种方式在添加英雄是，根据排名将英雄插入到指定位置
示例代码
package test;
public class LinkedList {
public static void main(String[] args){
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingLinkedList singLinkedList = new SingLinkedList();
// 加入
// singLinkedList.add(hero1);
// singLinkedList.add(hero2);
// singLinkedList.add(hero3);
// singLinkedList.add(hero4);
// 加入时将编号的顺序打乱
singLinkedList.addByOrder(hero3);
singLinkedList.addByOrder(hero1);
singLinkedList.addByOrder(hero4);
singLinkedList.addByOrder(hero2);
// 显示
singLinkedList.list();
}
}
// 定义SingLinkedList 管理我们的英雄
class SingLinkedList{
// 先初始化一份头节点，头结点不能动，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 思路：当不考虑编号顺序时
// 1、找到当前链表的最后节点
// 2、将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
// 因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
// 遍历链表，找到最后
while (true){
// 找到链表的最后
if (temp.next == null){
break;
}
// 如果没有找到最后，将temp后移
temp = temp.next;
}
// 当退出循环是，temp就指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = heroNode;
}
// 第二种方式在添加英雄是，根据排名将英雄插入到指定位置
// （如果有这个排名，则添加失败，并给出提示）
public void addByOrder(HeroNode heroNode){
// 因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
// 因为我们找到temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
// flag标志添加的编号是否存在，默认false
boolean flag = false;
while(true){
// 说明temp已经在链表的最后
if (temp.next == null){
break;
}
//位置找到，就在temp的后面插入
if (temp.next.no > heroNode.no){
break;
// 说明希望添加的heroNode的编号已经存在
} else if (temp.next.no == heroNode.no){
// 说明编号已存在
flag = true;
break;
}
// 后移，遍历当前链表
temp = temp.next;
}
if(flag){
System.out.println("准备插入的英雄编号：" + heroNode.no + "已经存在！");
} else {
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 显示遍历链表
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);
// 输出节点后一定要将temp后移，一定小心
temp = temp.next;
}
}
}
// 定义一个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 + '\'' +
'}';
}
}
加入时将编号的顺序打乱，添加成功后他们的顺序是排好的
重复添加测试
修改节点
将其中一个英雄修改信息
代码示例
package test;
public class LinkedList {
public static void main(String[] args){
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingLinkedList singLinkedList = new SingLinkedList();
// 加入
// singLinkedList.add(hero1);
// singLinkedList.add(hero2);
// singLinkedList.add(hero3);
// singLinkedList.add(hero4);
// 加入按编号的顺序
singLinkedList.addByOrder(hero3);
singLinkedList.addByOrder(hero1);
singLinkedList.addByOrder(hero4);
singLinkedList.addByOrder(hero2);
System.out.println("修改前！");
singLinkedList.list();
// 修改
System.out.println("修改后！");
HeroNode hh = new HeroNode(3, "小吴", "智多星-小吴");
singLinkedList.update(hh);
// 显示
singLinkedList.list();
}
}
// 定义SingLinkedList 管理我们的英雄
class SingLinkedList{
// 先初始化一份头节点，头结点不能动，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 思路：当不考虑编号顺序时
// 1、找到当前链表的最后节点
// 2、将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
// 因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
// 遍历链表，找到最后
while (true){
// 找到链表的最后
if (temp.next == null){
break;
}
// 如果没有找到最后，将temp后移
temp = temp.next;
}
// 当退出循环是，temp就指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = heroNode;
}
// 第二种方式在添加英雄是，根据排名将英雄插入到指定位置
// （如果有这个排名，则添加失败，并给出提示）
public void addByOrder(HeroNode heroNode){
// 因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
// 因为我们找到temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
// flag标志添加的编号是否存在，默认false
boolean flag = false;
while(true){
// 说明temp已经在链表的最后
if (temp.next == null){
break;
}
//位置找到，就在temp的后面插入
if (temp.next.no > heroNode.no){
break;
// 说明希望添加的heroNode的编号已经存在
} else if (temp.next.no == heroNode.no){
// 说明编号已存在
flag = true;
break;
}
// 后移，遍历当前链表
temp = temp.next;
}
if(flag){
System.out.println("准备插入的英雄编号：" + heroNode.no + "已经存在！");
} else {
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 修改节点的信息，根据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;
}
if (temp.no == newHeroNode.no){
// 找到
flag = true;
break;
}
temp = temp.next;
}
// 根据flag判断是否找到要修改的节点
if (flag){
temp.name = newHeroNode.name;
temp.nickName = newHeroNode.nickName;
} else {
System.out.println("没有找到标号为：" + newHeroNode.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);
// 输出节点后一定要将temp后移，一定小心
temp = temp.next;
}
}
}
// 定义一个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 + '\'' +
'}';
}
}
删除节点
实现思路
package test;
public class LinkedList {
public static void main(String[] args){
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingLinkedList singLinkedList = new SingLinkedList();
// 加入按编号的顺序
singLinkedList.addByOrder(hero3);
singLinkedList.addByOrder(hero1);
singLinkedList.addByOrder(hero4);
singLinkedList.addByOrder(hero2);
// System.out.println("修改前！");
// singLinkedList.list();
// 修改
// System.out.println("修改后！");
// HeroNode hh = new HeroNode(3, "小吴", "智多星-小吴");
// singLinkedList.update(hh);
System.out.println("删除前！");
singLinkedList.list();
System.out.println("删除后！");
singLinkedList.del(3);
singLinkedList.del(1);
// 显示
singLinkedList.list();
}
}
// 定义SingLinkedList 管理我们的英雄
class SingLinkedList{
// 先初始化一份头节点，头结点不能动，不存放具体数据
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 思路：当不考虑编号顺序时
// 1、找到当前链表的最后节点
// 2、将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
// 因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
// 遍历链表，找到最后
while (true){
// 找到链表的最后
if (temp.next == null){
break;
}
// 如果没有找到最后，将temp后移
temp = temp.next;
}
// 当退出循环是，temp就指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = heroNode;
}
// 第二种方式在添加英雄是，根据排名将英雄插入到指定位置
// （如果有这个排名，则添加失败，并给出提示）
public void addByOrder(HeroNode heroNode){
// 因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
// 因为我们找到temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
// flag标志添加的编号是否存在，默认false
boolean flag = false;
while(true){
// 说明temp已经在链表的最后
if (temp.next == null){
break;
}
//位置找到，就在temp的后面插入
if (temp.next.no > heroNode.no){
break;
// 说明希望添加的heroNode的编号已经存在
} else if (temp.next.no == heroNode.no){
// 说明编号已存在
flag = true;
break;
}
// 后移，遍历当前链表
temp = temp.next;
}
if(flag){
System.out.println("准备插入的英雄编号：" + heroNode.no + "已经存在！");
} else {
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 修改节点的信息，根据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;
}
if (temp.no == newHeroNode.no){
// 找到
flag = true;
break;
}
temp = temp.next;
}
// 根据flag判断是否找到要修改的节点
if (flag){
temp.name = newHeroNode.name;
temp.nickName = newHeroNode.nickName;
} else {
System.out.println("没有找到标号为：" + newHeroNode.no + "的节点。");
}
}
// 删除节点
// 思路
// 1、head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
// 2、说明我们在比较时，是temp.next.no和需要删除节点的no比较
public void del(int no){
HeroNode temp = head;
// 标志是否找到待删除节点
boolean flag = false;
while (true){
if (temp.next == null){
break;
}
if (temp.next.no == no){
// 找到待删除节点的前一个节点temp
flag = true;
break;
}
// temp后移，遍历
temp = temp.next;
}
// 判断flag
if(flag){
// 可以删除
temp.next = temp.next.next;
} else {
System.out.println("找不到要删除的" + 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);
// 输出节点后一定要将temp后移，一定小心
temp = temp.next;
}
}
}
// 定义一个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 + '\'' +
'}';
}
}
测试删除
扫一扫
5646
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
