文章目录
单链表
什么是单链表,链式存储结构详解
链表,别名链式存储结构或单链表,用于存储逻辑关系为 “一对一” 的数据。与顺序表不同,链表不限制数据的物理存储状态,换句话说,使用链表存储的数据元素,其物理存储位置是随机的。
例如,使用链表存储 {1,2,3},数据的物理存储状态如图 1 所示:
我们看到,图 1 根本无法体现出各数据之间的逻辑关系。对此,链表的解决方案是,每个数据元素在存储时都配备一个指针,用于指向自己的直接后继元素。如图 2 所示:
像图 2 这样,数据元素随机存储,并通过指针表示数据之间逻辑关系的存储结构就是链式存储结构。
链表的节点
链表中每个数据的存储都由以下两部分组成:
- 数据元素本身,其所在的区域称为数据域;
- 指向直接后继元素的指针,所在的区域称为指针域;
即链表中存储各数据元素的结构如图 3 所示:
图 3 所示的结构在链表中称为节点。也就是说,链表实际存储的是一个一个的节点,真正的数据元素包含在这些节点中,如图 4 所示:
头节点,头指针和首元节点
其实,图 4 所示的链表结构并不完整。一个完整的链表需要由以下几部分构成:
- 头指针(含义同下问的辅助指针):一个普通的指针,它的特点是永远指向链表第一个节点的位置。很明显,头指针用于指明链表的位置,便于后期找到链表并使用表中的数据;
- 节点:链表中的节点又细分为头节点、首元节点和其他节点:
头节点:其实就是一个不存任何数据的空节点,通常作为链表的第一个节点。对于链表来说,头节点不是必须的,它的作用只是为了方便解决某些实际问题;
首元节点:由于头节点(也就是空节点)的缘故,链表中称第一个存有数据的节点为首元节点。首元节点只是对链表中第一个存有数据节点的一个称谓,没有实际意义;
其他节点:链表中其他的节点;
因此,一个存储 {1,2,3} 的完整链表结构如图 5 所示:
注意:链表中有头节点时,头指针指向头节点;反之,若链表中没有头节点,则头指针指向首元节点。
单链表的实现
使用带 head 头的单向链表实现:王者荣耀英雄排行榜管理完成对英雄人物的增删改查操作。
1.尾部添加新节点
思路分析
- 首先要定义一个节点类,每个节点存放俩部分内容,数据域和指针域。
- 节点的数据域部分存放人物编号、姓名、外号。节点的指针域指向下一个节点。
- 编写构造器初始化数据域内容,为了显示方便,需要重写toString方法。
- 定义单向链表类,初始化一个头节点,整型数据初始化为0,字符类型数据初始化为空字符。注意:头节点不存放数据,作用就是表示单链表的头。
- 定义节点添加的方法,思路:(1)找到当前链表的最后节点,注意先判断链表是否为空。(2)将最后的节点next指向新节点,完成尾部添加。
- 定义显示链表方法,通过遍历输出节点的数据域。
代码实现
public class SingleLinkedListDemo {
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, "貂蝉", "仲夏夜之梦");
//创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);
//显示
singleLinkedList.list();
}
}
//定义SingleLinkedList,管理英雄
class SingleLinkedList {
//先初始化一个头节点,头节点不要动
private HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//思路:当不考虑编号顺序时
//1. 找到当前链表最后的节点
//2. 将最后的节点next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动,因此我们需要一个辅助变量 temp
HeroNode temp = head;
//遍历链表,找到最后
while (true) {
//当找到链表的最后时,temp.next==null
if (temp.next == null) {
break;
}
temp = temp.next; //如果没有找到最后,将temp后移
}
//当推出while循环时,temp就指向了链表的最后,然后让它指向新的节点。
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 + '\'' +
'}';
}
}
运行结果:
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
Process finished with exit code 0
注意事项
- 1.由于头节点不能动,所以在遍历的时候需要一个辅助变量,或者说是辅助指针,进行指针移动。
- 2.注意代码中俩次遍历链表时辅助指针的初始化区别。第一次遍历是在添加节点时找到链表最后节点,辅助指针是直接将head节点指针赋给它,是因为在最后节点的指针指向新节点之前,必须将先将该指针指向空;第二次遍历是在显示链表各个节点数据域的时候,而这次辅助指针的初始化和第一次不一样,是直接将头节点的下一个节点赋值给辅助指针,原因是头节点无数据域,所以显示数据需从含有第一个数据域的节点开始。
- 3.由于在代码中想要将节点的数据域输出,所以在节点类当要重写内置的toString方法。
2.按照编号插入新节点
思路分析
- 首先要定义一个节点类,每个节点存放俩部分内容,数据域和指针域。
- 节点的数据域部分存放人物编号、姓名、外号。节点的指针域指向下一个节点。
- 编写构造器初始化数据域内容,为了显示方便,需要重写toString方法。
- 定义单向链表类,初始化一个头节点,整型数据初始化为0,字符类型数据初始化为空字符。注意:头节点不存放数据,作用就是表示单链表的头。通过辅助指针找到新添加节点的位置,
- 定义节点插入的方法,使用辅助指针找到要插入位置的前一个位置,然后将新结点指向该位置的下一个节点,该位置的指针域指向新节点。
- 定义显示链表方法,通过遍历输出节点的数据域。
代码实现
代码和上述尾部添加法一样,只是多写了一个插入的方法。
public class SingleLinkedListDemo {
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, "貂蝉", "仲夏夜之梦");
//创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//插入节点,按照编号的顺序
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero3);
//显示
singleLinkedList.list();
}
}
//定义SingleLinkedList,管理英雄
class SingleLinkedList {
//先初始化一个头节点,头节点不要动
private HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//思路:当不考虑编号顺序时
//1. 找到当前链表最后的节点
//2. 将最后的节点next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动,因此我们需要一个辅助变量 temp
HeroNode temp = head;
//遍历链表,找到最后
while (true) {
//当找到链表的最后时,temp.next==null
if (temp.next == null) {
break;
}
temp = temp.next; //如果没有找到最后,将temp后移
}
//当推出while循环时,temp就指向了链表的最后,然后让它指向新的节点。
temp.next = heroNode;
}
//第二种方式添加英雄,根据排名编号插入(如果有这个排名,则添加失败,并给出提示)
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为这是一个单链表,因此找的temp是位于添加位置的前一个节点,否则无法插入
HeroNode temp = head;
boolean flag = false; //flag标识添加的编号是否存在,默认为false
while (true) {
if (temp.next == null) { //说明temp已经在链表最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到,在temp后面插入
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的hero编号已经存在
flag = true; //说明编号存在
break;
}
temp = temp.next;
}
//判断flag的值
if (flag) {//不能添加,说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在,不能加入\n", heroNode.no);
} else {
//插入到链表中,temp的后面
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 + '\'' +
'}';
}
运行结果:
准备插入的英雄的编号 3 已经存在,不能加入
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
Process finished with exit code 0
注意事项
要注意的地方则是新添加的插入方法。
- 1.注意辅助指针要找的位置,必须是所要插入地方的前一个位置,如果辅助指针指向后一个位置,那么下一步操作则是新节点指向后面这个位置,再下一步操作,发现并没有前驱节点无法指向新节点,“链子”也就断了。
- 2.另外需要注意的一个地方是,在代码中,是以编号的形式进行排序插入,所以得知道原先链表是否已经有了该编号的数据,所以得先判断,正如代码中设立flag一举动。
- 3.在辅助指针循环遍历判断完成之后,要将新节点指向后一个节点,而且该位置前一个节点需指向新节点,以连接好链表。
3.按照编号修改节点信息
思路分析
在修改节点信息update方法中:同样第一步先判断链表是否位空,然后借助辅助节点进行遍历查询,找到要修改的节点位置,通过flag判断是否是要修改的节点,最后进行信息更新。
新增的修改节点方法如下图:
主函数中新增的代码测试部分如下图:
代码演示
public class SingleLinkedListDemo {
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, "貂蝉", "仲夏夜之梦");
//创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero4);
//插入节点,按照编号的顺序
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
// singleLinkedList.addByOrder(hero3);
//显示
System.out.println("未修改的链表信息如下:");
singleLinkedList.list();
//测试修改节点的代码
HeroNode newHeroNode = new HeroNode(2, "花木兰", "麒麟志");
singleLinkedList.update(newHeroNode);
System.out.println("修改之后链表的信息如下:");
singleLinkedList.list();
}
}
//定义SingleLinkedList,管理英雄
class SingleLinkedList {
//先初始化一个头节点,头节点不要动
private HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//思路:当不考虑编号顺序时
//1. 找到当前链表最后的节点
//2. 将最后的节点next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动,因此我们需要一个辅助变量 temp
HeroNode temp = head;
//遍历链表,找到最后
while (true) {
//当找到链表的最后时,temp.next==null
if (temp.next == null) {
break;
}
temp = temp.next; //如果没有找到最后,将temp后移
}
//当推出while循环时,temp就指向了链表的最后,然后让它指向新的节点。
temp.next = heroNode;
}
//第二种方式添加英雄,根据排名编号插入(如果有这个排名,则添加失败,并给出提示)
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为这是一个单链表,因此找的temp是位于添加位置的前一个节点,否则无法插入
HeroNode temp = head;
boolean flag = false; //flag标识添加的编号是否存在,默认为false
while (true) {
if (temp.next == null) { //说明temp已经在链表最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到,在temp后面插入
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的hero编号已经存在
flag = true; //说明编号存在
break;
}
temp = temp.next;
}
//判断flag的值
if (flag) {//不能添加,说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在,不能加入\n", heroNode.no);
} else {
//插入到链表中,temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点的信息,根据no编号来修改,即no编号不能修改,如果编号修改,则可视为添加节点操作。
//根据 newHeroNode 的 no编号 来修改即可
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空!!!");
return;
}
//通过辅助指针找到需要修改的节点
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.printf("没有找到编号为%d的节点\n", 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 + '\'' +
'}';
}
}
运行结果:
未修改的链表信息如下:
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
修改之后链表的信息如下:
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='花木兰', nickname='麒麟志'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
Process finished with exit code 0
4.删除节点
思路分析
删除节点的重点:
- 1.辅助指针所要指向的位置:待删除节点的前一个位置。
- 2.temp.next = temp.next.next
代码演示
新增的删除节点方法如下图:
主函数中新增的测试代码如下图:
public class SingleLinkedListDemo {
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, "貂蝉", "仲夏夜之梦");
//创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero4);
//插入节点,按照编号的顺序
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
// singleLinkedList.addByOrder(hero3);
//显示
System.out.println("未修改的链表信息如下:");
singleLinkedList.list();
//测试修改节点的代码
HeroNode newHeroNode = new HeroNode(2, "花木兰", "麒麟志");
singleLinkedList.update(newHeroNode);
System.out.println("修改之后链表的信息如下:");
singleLinkedList.list();
//删除节点
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(2);
singleLinkedList.del(3);
System.out.println("删除第一个节点后链表的信息如下:");
singleLinkedList.list();
}
}
//定义SingleLinkedList,管理英雄
class SingleLinkedList {
//先初始化一个头节点,头节点不要动
private HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//思路:当不考虑编号顺序时
//1. 找到当前链表最后的节点
//2. 将最后的节点next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动,因此我们需要一个辅助变量 temp
HeroNode temp = head;
//遍历链表,找到最后
while (true) {
//当找到链表的最后时,temp.next==null
if (temp.next == null) {
break;
}
temp = temp.next; //如果没有找到最后,将temp后移
}
//当推出while循环时,temp就指向了链表的最后,然后让它指向新的节点。
temp.next = heroNode;
}
//第二种方式添加英雄,根据排名编号插入(如果有这个排名,则添加失败,并给出提示)
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为这是一个单链表,因此找的temp是位于添加位置的前一个节点,否则无法插入
HeroNode temp = head;
boolean flag = false; //flag标识添加的编号是否存在,默认为false
while (true) {
if (temp.next == null) { //说明temp已经在链表最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到,在temp后面插入
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的hero编号已经存在
flag = true; //说明编号存在
break;
}
temp = temp.next;
}
//判断flag的值
if (flag) {//不能添加,说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在,不能加入\n", heroNode.no);
} else {
//插入到链表中,temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点的信息,根据no编号来修改,即no编号不能修改,如果编号修改,则可视为添加节点操作。
//根据 newHeroNode 的 no编号 来修改即可
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空!!!");
return;
}
//通过辅助指针找到需要修改的节点
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.printf("没有找到编号为%d的节点\n", 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) { //找到要删除节点的前一个节点编号
flag = true;
break;
}
temp = temp.next;
}
if (flag) { //找到,可以删除了
temp.next = temp.next.next;
} else {
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);
//将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 + '\'' +
'}';
}
}
运行结果:
未修改的链表信息如下:
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
修改之后链表的信息如下:
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='花木兰', nickname='麒麟志'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
删除第一个节点后链表的信息如下:
链表为空!!!
Process finished with exit code 0
注意事项
- 1.由于是单链表,通过辅助指针要找的是被删除节点的前一个节点,否则无法删除节点。
- 2.被删除的节点,没有任何引用会指向它,会被Java的垃圾回收机制回收掉。
常用对链表的操作
1.求单链表中有效节点的个数
思路简单,在上述代码的基础上,直接遍历,计数器+1,就OK。需要注意的地方则是,该方法应先判断链表是否为空,如若位空,直接返回0值。
代码演示
添加一个得到节点个数的方法,如下:
public static int getLength(HeroNode head) {
if (head.next == null) {
return 0;
}
int length = 0;
//定义一个辅助变量
HeroNode cur = head.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
在链表类当中,添加返回头节点(Getter一波)的方法,是因为链表类中初始化的头节点是私有的。如下图:
主函数中的测试代码如下图:
运行结果如下图:
2.查找单链表中的倒数第k个节点
思路分析
- 编写一个方法,接受head节点,同时接受一个index。
- index表示的是倒数第index个节点。
- 先把链表从头到尾遍历一遍,得到链表的总的长度 getlength。
- 得到size后,从链表的第一个开始遍历(size-index)个,就可以得到。
- 如果找到了,则返回该节点,否则返回空null。
代码演示
注意这部分代码调用到了上面第一部分中所写的代码,所有内容完整的代码在本文最后。
public static HeroNode findLastIndexNode(HeroNode head, int index) {
//判断如果链表为空,返回空null
if (head.next == null) {
return null; //表示没有找到
}
//第一次遍历得到链表的长度(节点个数)
int size = getLength(head);
//第二次遍历 size-index 位置,就是我们倒数的第k个节点。
//先做一个index校验
if (index <= 0 || index > size) {
return null;
}
//定义一个辅助指针,for循环定位到倒数的index个
HeroNode cur = head.next;
for (int i = 0; i < size-index; i++) {
cur = cur.next;
}
return cur;
}
主函数中的测试代码如下图:
运行结果如下图:
注意事项
- 1.获取链表长度的方法中,要将头节点传入该方法,是因为要通过头指针定义辅助指针,原因是因为该方法卸载了链表类的外部,所以要传入。
- 2.在获取倒数第k个节点时,进行了俩次遍历,第一次遍历是为了获取整个链表的长度,然后再减去倒数第index个节点,就是我们要找到的节点,所以第二次遍历是则是遍历至 size-index 。
- 3.还有一点注意的地方则是传入index值是否合理,所以提前做一个校验。
3.单链表的反转
思路分析
反转效果图
思路:
- 1.先定义一个节点 reveerseHead = new HeroNode();
- 2.从头到位遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reverseHead的最前端。
- 3.原来的链表的 head.next = reverseHead.next
代码演示
/*
将单链表进行翻转【腾讯面试题】
*/
public static void reverseList(HeroNode head) {
//如果当前链表为空,或者只有一个节点,无需反转,直接返回
if (head.next == null || head.next.next == null) {
return;
}
//定义一个辅助指针(变量),帮助我们遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null; //指向当前节点[cur]的下一个节点
HeroNode resverseHead = new HeroNode(0, "", "");
//从头遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reverseHead的最前端
while (cur != null) {
next = cur.next; //暂时保存当前节点的下一个节点,因为后面需要使用
cur.next = resverseHead.next; //将cur的下一个节点指向新的链表的最前端
resverseHead.next = cur; //将cur连接到新的链表上
cur = next; //让cur后移
}
//将head.next 指向 reverseHead.next,实现单链表的翻转
head.next = resverseHead.next;
}
主函数测试代码:
运行结果:
原来链表的情况~~~~~~~
HeroNode{no=1, name='铠', nickname='绛天战甲'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
翻转单链表~~~~~~~~~
HeroNode{no=4, name='貂蝉', nickname='仲夏夜之梦'}
HeroNode{no=3, name='吕布', nickname='天魔缭乱'}
HeroNode{no=2, name='瑶妹', nickname='遇见神鹿'}
HeroNode{no=1, name='铠', nickname='绛天战甲'}
Process finished with exit code 0
完整Demo
这里是上文所阐述针对单链表操作的完整代码。上文中所写的代码有重复的地方,是为了查看运行结果,方便核对验证。
public class SingleLinkedListDemo {
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, "貂蝉", "仲夏夜之梦");
//创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);
//测试一下单链表的反转功能
System.out.println("原来链表的情况~~~~~~~");
singleLinkedList.list();
System.out.println("翻转单链表~~~~~~~~~");
reverseList(singleLinkedList.getHead());
singleLinkedList.list();
/*
//插入节点,按照编号的顺序
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
// singleLinkedList.addByOrder(hero3);
//显示
System.out.println("未修改的链表信息如下:");
singleLinkedList.list();
//测试修改节点的代码
HeroNode newHeroNode = new HeroNode(2, "花木兰", "麒麟志");
singleLinkedList.update(newHeroNode);
System.out.println("修改之后链表的信息如下:");
singleLinkedList.list();
//删除节点
singleLinkedList.del(4);
System.out.println("删除第一个节点后链表的信息如下:");
singleLinkedList.list();
//测试得到链表节点个数
System.out.println("有效的节点个数为:" + getLength(singleLinkedList.getHead()));
//测试倒数第k个节点
HeroNode result = findLastIndexNode(singleLinkedList.getHead(), 2);
System.out.println("res为:" + result);
*/
}
/*
将单链表进行翻转【腾讯面试题】
*/
public static void reverseList(HeroNode head) {
//如果当前链表为空,或者只有一个节点,无需反转,直接返回
if (head.next == null || head.next.next == null) {
return;
}
//定义一个辅助指针(变量),帮助我们遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null; //指向当前节点[cur]的下一个节点
HeroNode resverseHead = new HeroNode(0, "", "");
//从头遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reverseHead的最前端
while (cur != null) {
next = cur.next; //暂时保存当前节点的下一个节点,因为后面需要使用
cur.next = resverseHead.next; //将cur的下一个节点指向新的链表的最前端
resverseHead.next = cur; //将cur连接到新的链表上
cur = next; //让cur后移
}
//将head.next 指向 reverseHead.next,实现单链表的翻转
head.next = resverseHead.next;
}
/*
查找单链表中的倒数第k个节点【新浪面试题】
思路:
1.编写一个方法,接受head节点,同时接受一个index
2.index表示的是倒数第index个节点
3.先把链表从头到尾遍历一遍,得到链表的总的长度 getlength
4.得到size后,从链表的第一个开始遍历(size-index)个,就可以得到
5.如果找到了,则返回该节点,否则返回空null
*/
public static HeroNode findLastIndexNode(HeroNode head, int index) {
//判断如果链表为空,返回空null
if (head.next == null) {
return null; //表示没有找到
}
//第一次遍历得到链表的长度(节点个数)
int size = getLength(head);
//第二次遍历 size-index 位置,就是我们倒数的第k个节点。
//先做一个index校验
if (index <= 0 || index > size) {
return null;
}
//定义一个辅助指针,for循环定位到倒数的index个
HeroNode cur = head.next;
for (int i = 0; i < size-index; i++) {
cur = cur.next;
}
return cur;
}
//定义获取链表长度的方法
/*
head:链表的头节点
返回的就是有效节点的个数
*/
public static int getLength(HeroNode head) {
if (head.next == null) {
return 0;
}
int length = 0;
//定义一个辅助变量
HeroNode cur = head.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
//定义SingleLinkedList,管理英雄
class SingleLinkedList {
//先初始化一个头节点,头节点不要动
private HeroNode head = new HeroNode(0, "", "");
//返回头节点
public HeroNode getHead() {
return head;
}
//添加节点到单向链表
//思路:当不考虑编号顺序时
//1. 找到当前链表最后的节点
//2. 将最后的节点next指向新的节点
public void add(HeroNode heroNode) {
//因为head节点不能动,因此我们需要一个辅助变量 temp
HeroNode temp = head;
//遍历链表,找到最后
while (true) {
//当找到链表的最后时,temp.next==null
if (temp.next == null) {
break;
}
temp = temp.next; //如果没有找到最后,将temp后移
}
//当推出while循环时,temp就指向了链表的最后,然后让它指向新的节点。
temp.next = heroNode;
}
//第二种方式添加英雄,根据排名编号插入(如果有这个排名,则添加失败,并给出提示)
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动,因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为这是一个单链表,因此找的temp是位于添加位置的前一个节点,否则无法插入
HeroNode temp = head;
boolean flag = false; //flag标识添加的编号是否存在,默认为false
while (true) {
if (temp.next == null) { //说明temp已经在链表最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到,在temp后面插入
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的hero编号已经存在
flag = true; //说明编号存在
break;
}
temp = temp.next;
}
//判断flag的值
if (flag) {//不能添加,说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在,不能加入\n", heroNode.no);
} else {
//插入到链表中,temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点的信息,根据no编号来修改,即no编号不能修改,如果编号修改,则可视为添加节点操作。
//根据 newHeroNode 的 no编号 来修改即可
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空!!!");
return;
}
//通过辅助指针找到需要修改的节点
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.printf("没有找到编号为%d的节点\n", 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) { //找到要删除节点的前一个节点编号
flag = true;
break;
}
temp = temp.next;
}
if (flag) { //找到,可以删除了
temp.next = temp.next.next;
} else {
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);
//将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 + '\'' +
'}';
}
}