文章目录
- 前言
- 一：链表(LinkedList)
- 1.1 链表分类
- 1.2 介绍
- 1.3 链表的概念及结构
- 二：单链表
- 2.1 单链表结构示意图
- 2.2 单链表的应用实例
- 2.3 单链表的添加
- 2.3.1 直接添加到链表的尾部（不考虑顺序）
- 2.3.1.1 整体思路
- 2.3.1.2 代码实现
- 2.3.2 按顺序插入到指定位置(如果有这个排名，则添加失败，并给出提示)
- 2.3.2.1 思路分析
- 2.3.2.2 代码实现
- 2.3.2.3 测试
- 2.4 单链表的修改
- 2.5 单链表的删除
- 2.5.1 思路分析
- 2.5.2 代码实现
- 2.5.3 测试
- 三：常见的单链表面试题
- 3.1 求单链表中有效节点的个数
- 3.2 查找单链表中的倒数第k个结点
- 3.2.1 思路
- 3.2.2 代码实现
- 3.3 单链表的反转
- 3.3.1 思路分析
- 3.3.2 代码实现
前言
问：为什么使用链表？
答：当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此又引入了LinkedList，即链表结构。
一：链表(LinkedList)
1.1 链表分类
链表可分为三类：单链表、双向链表、循环列表
单向或者双向：
带头或者不带头：
循环或者非循环：
1.2 介绍
链表是有序的列表，但是它在内存中是存储如下
- 链表是以节点的方式来存储,是链式存储
- 每个节点包含 data 域， next 域：指向下一个节点.
- 如图：发现链表的各个节点不一定是连续存储.
- 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
1.3 链表的概念及结构
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的。类似于一节又一节火车。
二：单链表
2.1 单链表结构示意图
2.2 单链表的应用实例
实例：使用带head头的单向链表实现 –人物排行榜管理
功能：完成对人物的增删改查操作
2.3 单链表的添加
2.3.1 直接添加到链表的尾部（不考虑顺序）
2.3.1.1 整体思路
- 先创建一个head头节点，作用就是表示单链表的头
- 后面我们没添加一个节点，就直接加入到链表的最后
- 通过一个辅助变量遍历，帮助遍历整个链表
2.3.1.2 代码实现
public class SingleLinkedListDemo {
public static void main(String[] args) {
//创建节点
HeroNode hero1 = new HeroNode(1, "蔡徐坤", "ikun");
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.list();
}
}
/**
* 定义singleLinkedList来管理我们的人员
*/
class SingleLinkedList {
//先初始化头节点,头节点不要动,不存放具体数据
private final HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单链表
* 思路：当不考虑编号顺序时，
* 1.找到当前列表的最后一个节点
* 2.将最后这个节点的next指向新的节点
*
* @param heroNode
*/
public void add(HeroNode heroNode) {
//因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
HeroNode temp = head;
//遍历链表，找到最后一个节点
while (temp.next != null) {
//找到链表的最后一个节点
//如果没有找到，就将temp临时变量后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
temp.next = heroNode;
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点不能动，因此我们需要使用一个辅助变量来遍历
HeroNode temp = head.next;
while (temp != null) {
//判断是否到链表的最后
//输出节点信息
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方法
*
* @return String
*/
@Override
public String toString() {
return "HeroNode{" + "no=" + no + ", name='" + name + ", nickname='" + nickname + '}';
}
}
2.3.2 按顺序插入到指定位置(如果有这个排名，则添加失败，并给出提示)
2.3.2.1 思路分析
需按照编号的书序添加：
- 首先找到新添加的节点的位置，是通过辅助变量（指针），通过遍历来搞定
- 新的节点.next = temp.next;
- 将temp.next指向新的节点
2.3.2.2 代码实现
/**
* 按照顺序插入到指定位置，如果有这个排名，则添加失败，并给出提示
*
* @param heroNode
*/
public void addByOrder(HeroNode heroNode) {
//因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
//因为是单链表，所以我们找的temp是位于添加位置的前一个节点，否则无法插入
HeroNode temp = head;
//添加的编号是否存在，默认为false
boolean flag = false;
//说明temp已经在链表的最后
while (true) {
if (temp.next == null) {
break;
}
//位置找到，就在temp的后面插入
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//此时说明heroNode编号已经存在,将flag变为true
flag = true;
}
//如果以上条件都不满足，则将temp后移
temp = temp.next;
}
//判断flag的值，如果flag为true则不能添加
if (flag) {
System.out.printf("编号%d,已经存在,无法添加", heroNode.no);
} else {
//插入到链表中，temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
2.3.2.3 测试
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero5);
此时顺序添加功能就实现了！
2.4 单链表的修改
/**
* 通过no编号进行修改，no编号不可以修改
*
* @param newHeroNode
*/
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 = temp.next;
}
//根据flag判断是否找到该节点
if(flag){
//找到了，则将temp重新赋值
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
} else {
//没找到该节点
System.out.printf("没有找到编号为%d的节点，无法修改\n", newHeroNode.no);
}
}
2.5 单链表的删除
2.5.1 思路分析
从单链表中删除一个节点的思路：
- 我们需要先找到删除节点的前一个节点temp
- temp.next = temp.next.next
- 被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收
2.5.2 代码实现
/**
* 思路
* 1.因为头节点不能动，所以我们需要一个temp临时变量来找到删除节点的前一个节点
* 2.在比较时，我们需要将temp.next.no和需要删除节点的no进行比较
*
* @param no 需要删除节点的编号
*/
public void delete(int no) {
//因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
//因为是单链表，所以我们找的temp是位于添加位置的前一个节点
HeroNode temp = head;
//表示是否找到该节点
boolean flag = false;
while (true) {
//说明temp已经在链表的最后
if (temp.next == null) {
break;
}
//找到待删除节点的前一个节点
if (temp.next.no == no) {
flag = true;
break;
}
//如果以上条件都不满足，则将temp后移
temp = temp.next;
}
//判断flag的值，如果flag为true则找到
if (flag) {
//可以删除
temp.next = temp.next.next;
} else {
System.out.printf("编号%d,不存在,无法删除", no);
}
}
2.5.3 测试
删除节点信息为3的信息
//删除一个节点信息
singleLinkedList.delete(3);
三：常见的单链表面试题
3.1 求单链表中有效节点的个数
/**
* 获取单链表的节点个数
* 注:如果是带头结点的，需求不统计头节点
*
* @param head
* @return
*/
public static int getLength(HeroNode head) {
if (head.next == null) {
//空链表
return 0;
}
int length = 0;
//定义一个辅助变量
HeroNode temp = head.next;
//遍历
while (temp != null) {
length++;
temp = temp.next;
}
return length;
}
3.2 查找单链表中的倒数第k个结点
3.2.1 思路
1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
2.先把链表从头到尾遍历，得到链表的总长度size
3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
4.如果找到了则返回该节点，否则返回null
3.2.2 代码实现
/**
* 查找单链表中的倒数第k个结点
* 思路：
* 1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
* 2.先把链表从头到尾遍历，得到链表的总长度size
* 3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
* 4.如果找到了则返回该节点，否则返回null
*
* @param head
* @param index
* @return
*/
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
//假设数组长度为8，我们需要找到倒数第3个数据，则就是正数第8 - 3 = 5个数据
HeroNode temp = head.next;
for (int i = 0; i < size - index; i++) {
temp = temp.next;
}
return temp;
}
3.3 单链表的反转
3.3.1 思路分析
思路：
1.先定义一个节点，reverseHead = new HeroHead();
2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并且放在新的链表reverseHead的最前端
3.原来的链表的head.next = reverseHead.next;
3.3.2 代码实现
/**
* 单链表的反转
* 思路
* 1.先定义一个节点，reverseHead = new HeroHead();
* 2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并且放在新的链表reverseHead的最前端
* 3.原来的链表的head.next = reverseHead.next;
*
* @param head
*/
public static void reverseList(HeroNode head) {
//如果只有一个节点或者链表是空的，则不需要反转
if (head.next == null || head.next.next == null) {
return;
}
//定义一个辅助变量，来帮助我们循环遍历链表,cur表示当前节点
HeroNode cur = head.next;
//指向当前节点cur的下一个节点
HeroNode next = null;
//定义一个空的链表
HeroNode reverseNode = new HeroNode(0, "", "");
//遍历原来的链表，每遍历一个节点，就将其取出，放到新链表reverseNode的最前端
//当cur为null时，说明已经遍历结束
while (cur != null) {
//先暂时保存当前节点的下一个节点
next = cur.next;
//将当前节点的下一个节点赋值给反转链表的最前端
cur.next = reverseNode.next;
//将cur连接到新的链表上
reverseNode.next = cur;
//将cur后移，继续向下遍历
cur = next;
}
//将head.next指向reverseNode.next,实现单链表的反转
head.next = reverseNode.next;
}
