【数据结构与算法】链表
文章目录
- 前言
- 一：链表(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 代码实现
- 四：双向环形链表
-
- 4.1 单链表的不足
- 4.2 介绍
- 4.3 定义双向循环链表节点类
- 4.4 将元素追加到链表的末尾
- 4.5 将元素插入到指定下标处
- 4.6 返回指定下标处的元素
- 4.7 移除指定位置处的元素
- 4.8 返回指定位置的节点
- 4.9 重写toString方法
- 4.10 测试
前言
问：为什么使用链表？
答：当在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;
}
四：双向环形链表
4.1 单链表的不足
- 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
- 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点。
4.2 介绍
有两个指针域，一个指向后一个结点，一个指向前一个结点。它存储了前一个结点的地址与后一个结点的地址，所以可以很方便的进行向前遍历或者向后遍历。同时它还是一个循环链表，可以通过第一个结点直接找到最后一个结点。
next：指向下一个节点
pre：指向上一个节点
4.3 定义双向循环链表节点类
public class LinkedList<E> {
/**
* head用于存放头节点信息
*/
private Node head;
/**
* 链表的长度
*/
private Integer size = 0;
/**
* Node用于描述表中的一个节点
* 其中，data用于存放于元素
* next是存放前继节点
* prev用于存放指向其后继节点
*/
class Node {
//存放数据
E data;
//前继节点
Node next;
//后继节点
Node prev;
//构造器
public Node(E e){
data = e;
}
}
/**
* 获得链表的长度
*
* @return
*/
public int size() {
return size;
}
}
4.4 将元素追加到链表的末尾
/**
* 将元素追加到链表的末尾
* @param e 被添加的元素
* @return 添加成功，返回true
*/
public boolean add(E e){
//将元素封装成一个节点
Node node = new Node(e);
//如果链表为空，则新节点就是头节点
if(head == null){
head = node;
head.next = node;
head.prev = node;
//链表的长度加1
size ++;
return true;
}
//找到末尾节点地址
Node last = head.prev;
//将新节点添加到未节点后面
last.next = node;
node.next = head;
head.prev = node;
node.prev = last;
//链表的长度加1
size ++;
return true;
}
4.5 将元素插入到指定下标处
/**
* 将元素插入到指定下标处
* @param index
* @param e
*/
public void add(int index,E e){
if( index < 0 || index > size ){
throw new IndexOutOfBoundsException("数组下标越界异常");
}
if(index == size){
add(e);
}
//将元素封装成一个节点
Node node = new Node(e);
Node next = getNode(index);
Node prev = next.prev;
next.prev = node;
node.prev = prev;
prev.next = node;
node.next = next;
if(index == 0){
head = node;
}
size ++;
}
4.6 返回指定下标处的元素
/**
* 返回指定下标处的元素
* @param index 下标，从0开始
* @return 对应位置处的元素
*/
public E get(Integer index){
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("数组下标越界异常");
}
Node node = getNode(index);
//返回该节点存放的数据
return node.data;
}
4.7 移除指定位置处的元素
/**
* 移除指定位置处的元素
*
* @return
*/
public E remove(Integer index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("数组下标越界异常");
}
//如果链表只有一个元素,则删除该节点以后，需要将head设置为null,并返回删除的元素
if (size == 1) {
E data = head.data;
head = null;
size--;
return data;
}
//找到要删除的节点
Node node = this.getNode(index);
//找到该节点的前驱节点和后继节点
Node next = node.next;
Node prev = node.prev;
//将该节点删除(其实就是在prev和next之间建立引用关系)
prev.next = next;
next.prev = prev;
//如果被删除的元素为头节点,则其下一个节点为头节点
if (index == 0) {
head = next;
}
//链表长度减1
size--;
return node.data;
}
4.8 返回指定位置的节点
/**
* 返回指定位置的节点
*
* @param index
* @return
*/
private Node getNode(Integer index) {
//从头结点开始遍历
Node node = this.head;
//此时可以用移位运算
//为了提升性能，可以通过比较index与链表的长度的一半来决定是向前遍历还是向后遍历
if (index < size >> 1) {
for (int i = 0; i < index; i++) {
node = node.next;
}
} else {
for (int i = size; i > index; i--) {
node = node.prev;
}
}
return node;
}
4.9 重写toString方法
@Override
public String toString() {
if (head == null) {
return "[]";
}
StringBuilder stringBuilder = new StringBuilder("[");
stringBuilder.append(head.data);
Node node = head.next;
while (node.next != head) {
stringBuilder.append(",").append(node.data);
//继续查找下个节点
node = node.next;
}
return stringBuilder.append("]").toString();
}
4.10 测试
public class LinkedListTest {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
List<Integer> arrayList = new ArrayList<>();
list.add("Curry");
list.add("Green");
list.add("Thompson");
list.add("Durant");
list.add("James");
System.out.println("size():" + list.size());
System.out.println("get(2):" + list.get(2));
System.out.println("list:" + list.toString());
}
}
