目录
什么是链表？
链表是一种常用的数据结构，它在内存中是非连续存储的，每个元素（称为节点）包含数据和一个指针，这个指针指向链表中的下一个节点。链表的主要优点是插入和删除操作不需要移动大量元素，这与数组形成对比，数组在进行插入或删除时可能需要移动多个元素来保持连续性。
相关概念
常规概念：
- 节点(Node): 链表中的每个元素。通常包含数据和指向下一个节点的指针。
- 头节点(Head): 链表的第一个节点。
- 尾节点(Tail): 链表的最后一个节点，其指针通常指向NULL。
链表分类：
- 单链表(Singly Linked List): 最简单的链表形式，其中每个节点仅有一个指向下一个节点的指针。
- 双向链表(Doubly Linked List): 每个节点有两个指针，一个指向下一个节点，另一个指向前一个节点。这使得遍历可以向前或向后进行，并且删除操作更简单。
- 循环链表(Circular Linked List): 链表的尾节点的指针不是指向NULL，而是回绕指向头节点。这种结构允许从任何位置开始遍历整个链表。
链表的特点
- 动态大小:
- 链表的大小可以在运行时动态改变，这意味着你可以随时添加或删除元素，而不必事先确定其大小，这与数组不同，数组在创建时就需要指定大小。
- 插入和删除效率高:
- 在链表中插入或删除元素只需要更新相邻节点的指针，这通常是一个常数时间的操作（O(1)）。相比之下，对于数组，插入或删除元素可能需要移动大量元素以保持连续性，这会导致较高的时间复杂度（O(n)）。
- 非连续存储:
- 链表的元素不必在内存中连续存储，它们可以分散在内存的不同位置，这使得链表能够更有效地利用内存，特别是在内存碎片较多的情况下。
- 指针的使用:
- 链表中的每个节点都包含一个指针，用于指向链表中的下一个节点。在双向链表中，每个节点还包含一个指向前一个节点的指针。
- 随机访问效率低:
- 由于链表的非连续性和基于指针的结构，直接访问链表中的某个特定位置需要从头节点开始依次遍历，直到找到该位置，这通常是一个线性时间的操作（O(n)）。
- 额外的空间开销:
- 除了存储数据之外，链表还需要额外的空间来存储指针信息，这会增加每个节点的空间需求。
- 灵活性:
- 链表提供了高度的灵活性，可以轻松地构建各种类型的链表，如单向链表、双向链表、循环链表等，每种类型都有其特定的应用场景。
- 内存管理:
- 链表的节点是在运行时动态分配的，因此链表的内存管理通常依赖于编程语言的垃圾回收机制或手动内存管理。
- 迭代和遍历:
- 遍历链表通常是从头节点开始，沿着指针逐个访问每个节点，直到到达尾节点。对于循环链表，遍历需要特别处理以避免无限循环。
- 链表操作:
- 包括但不限于初始化、插入、删除、查找、排序、反转等，这些操作可以通过修改节点之间的连接来实现。
链表因其动态性和高效插入删除性能，在很多场景下非常有用，尤其是在处理不确定大小的数据集时。然而，它的随机访问性能较差，因此在需要频繁随机访问的场景中可能不是最佳选择。
链表的常规应用场景
- 操作系统内存管理:
- 操作系统使用链表来管理内存页或块，例如，空闲内存块可以用链表组织，以便快速分配和回收。
- 文件系统:
- 文件系统的目录和文件结构可以用链表表示，尤其是当文件或目录的数量和位置不确定时。
- 编译器和解析器:
- 编译器和解析器经常使用链表来构建抽象语法树（AST），以及存储符号表和标识符等信息。
- 数据库管理系统:
- 数据库系统可能使用链表来管理记录，尤其是在需要频繁插入和删除记录的情况下。
- 缓存和队列:
- 链表非常适合实现缓存机制，如最近最少使用（LRU）缓存策略。同样，链表也是实现先进先出（FIFO）队列的理想选择。
- 链式哈希表:
- 当哈希冲突发生时，链表可以用来链接具有相同哈希值的项，从而解决冲突。
- 多任务调度:
- 操作系统中，就绪队列和等待队列可以用链表实现，以管理进程的调度。
- 算法和数据处理:
- 许多算法，如排序和搜索算法，可以利用链表的特性来提高效率或简化实现。
链表之所以在这些场景中被广泛使用，是因为它们提供了动态大小调整的能力，以及在某些操作上的高效性，如插入和删除。然而，链表的随机访问性能较差，因此在需要频繁随机访问的场景中，链表可能不是最理想的选择。
算法题
反转链表
描述
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
数据范围： 0≤n≤1000
要求：空间复杂度 O(1) ，时间复杂度O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：
示例1
输入：{1,2,3}
返回值：{3,2,1}
示例2
输入：{}
返回值：{}
说明：空链表则输出空
解题思路
- 使用数据结构栈或者递归，利用先进后出的思想。
- 使用双指针进行原地翻转方向。
AC代码：
使用数据结构 --- 栈和递归解法
public static void main(String[] args) {
ListNode node = new ListNode(1);
node.next = new ListNode(2);
node.next.next = new ListNode(3);
node.next.next.next = new ListNode(4);
System.out.println("利用栈 == " + ReverseList(node));
System.out.println("利用递归 == " + Traversal(recursion(node)));
}
/**
* 遍历链表
* @param listNode
* @return
*/
private static String Traversal(ListNode listNode) {
int[] arr = new int[getLength(listNode)];
int i = 0 ;
while (listNode != null){
arr[i] = listNode.val;
listNode = listNode.next;
i++;
}
return Arrays.toString(arr);
}
/**
* 获取链表长度
* @param head
* @return
*/
public static int getLength(ListNode head){
int length = 0;
while (head != null){
length++;
head = head.next;
}
return length;
}
public static class ListNode {
int val;
ListNode next = null;
public ListNode(int val) {
this.val = val;
}
}
//利用栈
public static String ReverseList (ListNode head) {
// 链表为空 直接 return null
if(head == null){
return null;
}
// 新建一个ArrayList存储值
ArrayList<Integer> res = new ArrayList<>();
Stack<Integer> stack = new Stack<>();
// 将链表的值存入栈中
while (head != null){
stack.push(head.val);
head = head.next;
}
while (!stack.isEmpty()){
res.add(stack.pop());
}
return res.toString();
}
//递归解法
public static ListNode recursion(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode res = recursion(head.next);
head.next.next = head;
head.next = null;
return res;
}
双指针解法
package com.lhd.链表;
import java.util.Arrays;
public class 反转链表_双指针 {
public static void main(String[] args) {
ListNode node = new ListNode(1);
node.next = new ListNode(2);
node.next.next = new ListNode(3);
node.next.next.next = new ListNode(4);
String start = Traversal(node);
System.out.println("初始链表 === " + start);
ListNode listNode = ReverseList(node);
String end = Traversal(listNode);
System.out.println("反转后的链表 === " + end);
}
/**
* 反转链表
* @param head
* @return
*/
public static ListNode ReverseList (ListNode head) {
if(head == null){
return null;
}
//定义两个指针
ListNode cur = head;
//指向空 构造新的链表
ListNode pre = null;
while(cur != null){
// 保存cur的下一个节点
ListNode temp = cur.next;
//cur指向pre
cur.next = pre;
//移动pre
pre = cur;
//移动cur cur继续去拆给定链表的节点
cur = temp;
}
return pre;
}
/**
* 遍历链表
* @param listNode
* @return
*/
private static String Traversal(ListNode listNode) {
int[] arr = new int[getLength(listNode)];
int i = 0 ;
while (listNode != null){
arr[i] = listNode.val;
listNode = listNode.next;
i++;
}
return Arrays.toString(arr);
}
/**
* 构造链表
*/
public static class ListNode {
int val;
ListNode next = null;
public ListNode(int val) {
this.val = val;
}
}
/**
* 获取链表长度
* @param head
* @return
*/
public static int getLength(ListNode head){
int length = 0;
while (head != null){
length++;
head = head.next;
}
return length;
}
}
头插法
public static ListNode reverseList(ListNode head) {
if (head == null || head.next == null){
return head;
}
//定义一个新的表头指向head
ListNode newH = head;
while (head.next != null){
// 保留head的下一个节点
ListNode curr = head.next;
// 将head指向curr的下一个节点 相当于head指向下下个节点
head.next = curr.next;
// 将curr的下一个节点指向newH 相当于连接到newH新链表中
curr.next = newH;
// 后移指针，保证将每个新进的节点拼接在最后
newH = curr;
}
//返回新的表头
return newH;
}
/*删除链表中的节点
描述
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。
1.此题对比原题有改动
2.题目保证链表中节点的值互不相同
3.该题只会输出返回的链表和结果做对比，所以若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
数据范围:
0<=链表节点值<=10000
0<=链表长度<=10000
示例1
输入：{2,5,1,9},5
返回值：
{2,1,9}说明：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 2 -> 1 -> 9
示例2
输入：{2,5,1,9},1
返回值：
{2,5,9}说明：给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 2 -> 5 -> 9
解题思路
- 双指针 一个表示前序节点，一个表示当前节点
- cur负责找到需要删除的节点 pre负责连接当前结点的下一个节点(相当于一个删除操作)。
37个用例过36个的代码
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param val int整型
* @return ListNode类
*/
public ListNode deleteNode (ListNode head, int val) {
// write code here
if (head == null || head.next == null){
return head;
}
ListNode cur = head;
ListNode pre = head;
while (cur.next != null){
if (cur.val == val){
pre.next = cur.next;
break;
}
pre = cur;
cur = cur.next;
}
return head;
}
以上用例有一个没过的原因，没有判断第一个头结点的值就是要删除的值。
AC代码
不带头结点
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param val int整型
* @return ListNode类
*/
public ListNode deleteNode (ListNode head, int val) {
// write code here
// 如果头结点的值刚好是val
if (head.val == val){
head = head.next;
return head;
}
// 当前结点
ListNode cur = head;
// 前序结点
ListNode pre = head;
while (cur != null) {
// 找到目标结点
if (cur.val == val) {
// 跳过当前结点 直接指向cur的下一个元素 相当于删除操作
pre.next = cur.next;
break;
}
// 后移指针
pre = cur;
// 后移指针
cur = cur.next;
}
return head;
}
}带头结点
public static ListNode deleteNode (ListNode head, int val) {
// write code here
// 创建一个新的头结点
ListNode res = new ListNode(0);
res.next = head;
ListNode cur = head;
ListNode pre = res;
while (cur.next != null){
if (cur.val == val){
pre.next = cur.next;
break;
}
// 后移pre
pre = cur;
// 后移cur
cur = cur.next;
}
// 返回头结点
return res.next;
}合并两个排序的链表
描述
输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。
数据范围： 0≤n≤1000 0≤n≤1000，−1000≤节点值≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：
示例1
输入：{1,3,5},{2,4,6}
返回值：{1,2,3,4,5,6}
示例2
输入：{},{}
返回值：{}
示例3
输入：{-1,2,4},{1,3,4}
返回值：{-1,1,2,3,4,4}
解题思路
当两个链表都不为空的时候，每次去找两个链表中最小的值，用cur指向非空链表，相应链表结点后移，
每次循环cur也要后移, 保证后续的节点都是接在最后一个节点上，如果循环结束，还有链表为非空，因为链表都是有序的，cur直接指向非空链表。
AC代码
package com.lhd.链表;
import java.util.Arrays;
public class ListNode {
int val;
ListNode next = null;
public ListNode(int val) {
this.val = val;
}
// 自定义遍历链表的方法
public String Traversal(ListNode listNode) {
int[] arr = new int[getLength(listNode)];
int i = 0 ;
while (listNode != null){
arr[i] = listNode.val;
listNode = listNode.next;
i++;
}
return Arrays.toString(arr);
}
// 获取链表长度
public int getLength(ListNode head) {
int length = 0;
while (head != null) {
length++;
head = head.next;
}
return length;
}
}
public static void main(String[] args) {
ListNode pHead1 = new ListNode(1);
pHead1.next = new ListNode(3);
pHead1.next.next = new ListNode(5);
System.out.println("pHead1 ==" + pHead1.Traversal(pHead1));
ListNode pHead2 = new ListNode(2);
pHead2.next = new ListNode(4);
pHead2.next.next = new ListNode(6);
System.out.println("pHead2 ==" + pHead2.Traversal(pHead2));
ListNode res = recursion(pHead1, pHead2);
String traversal = res.Traversal(res);
System.out.println("合并后的结果 ===" + traversal);
}
/**
* 常规解法
* @param pHead1
* @param pHead2
* @return
*/
public static ListNode Merge (ListNode pHead1, ListNode pHead2) {
// write code here
// 判断两个链表是是否有为空的
if (pHead1 == null || pHead2 == null){
return pHead1 == null ? pHead2 : pHead1;
}
// 创建一个头结点
ListNode head = new ListNode(0);
ListNode cur = head;
while (pHead1 != null && pHead2 != null){
// 找到两个链表中小的值保存到head中
if (pHead1.val < pHead2.val){
// pHead1的值小,cur指向pHead1
cur.next = pHead1;
// pHead1往后移一位
pHead1 = pHead1.next;
}else {
// pHead2的值小,cur指向pHead2
cur.next = pHead2;
// pHead2往后移一位
pHead2 = pHead2.next;
}
//移动指针 使得更新的值都在最后一个节点上
cur = cur.next;
}
// 判空
if (pHead1 == null){
cur.next = pHead2;
}else {
cur.next = pHead1;
}
return head.next;
}
/**
* 递归解法
* @param pHead1
* @param pHead2
* @return
*/
public static ListNode recursion (ListNode pHead1, ListNode pHead2) {
// write code here
// 判断两个链表是是否有为空的
if (pHead1 == null || pHead2 == null){
return pHead1 == null ? pHead2 : pHead1;
}
if (pHead1.val < pHead2.val){
pHead1.next = recursion(pHead1.next,pHead2);
System.out.println("pHead1.val == " + pHead1.val);
return pHead1;
}else {
pHead2.next = recursion(pHead1,pHead2.next);
System.out.println("pHead2.val == " + pHead2.val);
return pHead2;
}
}
两个链表的第一个公共结点
描述
输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
数据范围：n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：
可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。
输入描述：
输入分为是3段，第一段是第一个链表的非公共部分，第二段是第二个链表的非公共部分，第三段是第一个链表和第二个链表的公共部分。 后台会将这3个参数组装为两个链表，并将这两个链表对应的头节点传入到函数FindFirstCommonNode里面，用户得到的输入只有pHead1和pHead2。
返回值描述：
返回传入的pHead1和pHead2的第一个公共结点，后台会打印以该节点为头节点的链表。
输入：{1,2,3},{4,5},{6,7}
返回值：{6,7}
说明：第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分
这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的
示例2
输入：{1},{2,3},{}
返回值：{}
说明：2个链表没有公共节点 ,返回null，后台打印{}
解题思路
- 使用两个指针p1 p2 分别指向pHead1 和 pHead2
- 用一个循环去判断p1是否等于p2，每次循环先判断这两个指针是否为null，满足条件则用当前指针指向另外一个链表
AC代码
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
// p1 指向 A 链表头结点，p2 指向 B 链表头结点
ListNode p1 = pHead1, p2 = pHead2;
while (p1 != p2) {
// p1 走一步，如果走到 A 链表末尾，转到 B 链表
if (p1 == null) p1 = pHead2;
else p1 = p1.next;
// p2 走一步，如果走到 B 链表末尾，转到 A 链表
if (p2 == null) p2 = pHead1;
else p2 = p2.next;
}
return p1;
}
}链表中环的入口结点
描述
给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。
数据范围： n≤10000，1<=结点值<=10000
要求：空间复杂度O(1)，时间复杂度 O(n)
例如，输入{1,2},{3,4,5}时，对应的环形链表如下图所示：
可以看到环的入口结点的结点值为3，所以返回结点值为3的结点。
输入描述：
输入分为2段，第一段是入环前的链表部分，第二段是链表环的部分，后台会根据第二段是否为空将这两段组装成一个无环或者有环单链表
返回值描述：
返回链表的环的入口结点即可，我们后台程序会打印这个结点对应的结点值；若没有，则返回对应编程语言的空结点即可。
示例1
输入：{1,2},{3,4,5}
返回值：3
说明：返回环形链表入口结点，我们后台程序会打印该环形链表入口结点对应的结点值，即3
示例2
输入：{1},{}
返回值："null"
说明：没有环，返回对应编程语言的空结点，后台程序会打印"null"
示例3
输入：{},{2}
返回值：2
说明：环的部分只有一个结点，所以返回该环形链表入口结点，后台程序打印该结点对应的结点值，即2
解题思路
首先可以假设：
fast走过的路程为： x + m * (y + z) + y （m为fast走过的环的圈数，为整数）
slow走过的路程为：x + n * (y + z) + y （n为fast走过的环的圈数，为整数）
fast的速度为slow的两倍，则以下式子成立
x + m(y + z) + y = 2 * (x + n*(y + z) + y）
(m - 2n) * (y + z) = x + y
- y + z 为环的路程
- x + y 为 表头到相遇的路程
由此可得
整数倍的圈的路程等于 = 表头到相遇的位置
- 先判断链表是否为空，为空则不可能出现环
- 首先判断是否有环，定义快慢指针去指向这个链表，去找到相遇的那个节点。
- 将相遇的节点存储在slow中，判断slow是否为null，不为空，将fast重新指向表头。
- fast从表头开始，slow从他们相遇的地方开始。返回两个指针相遇的那个节点，就是链表环的入口节点。
AC代码
双指针
public ListNode EntryNodeOfLoop(ListNode pHead) {
ListNode slow = hasCycle(pHead);
// 如果 slow 为null则无环
if (slow == null){
return null;
}
// 将快指针指向头结点从新开始移动
ListNode fast = pHead;
while (fast != slow){
//正常移动指针
fast = fast.next;
slow = slow.next;
}
return slow;
}
public ListNode hasCycle(ListNode pHead){
// 判断pHead是否为空
if(pHead == null){
return null;
}
ListNode fast = pHead;
ListNode slow = pHead;
// fast 会先到链尾
while (fast != null && fast.next != null){
//快指针走两步
fast = fast.next.next;
//慢指针走一步
slow = slow.next;
// 没走完一次判断是否相等 即相遇
if (slow == fast){
return slow;
}
}
// 若走完一次没有相遇 则无环
return null;
}使用数据结构-Set
if (pHead == null){
return null;
}
//使用 Set集合来存储pHead中的节点
HashSet<ListNode> set = new HashSet<>();
while (pHead != null){
// 判断pHead中是否有重复节点
if (set.contains(pHead)){
return pHead;
}
// 不重复添加到set
set.add(pHead);
// 后移指针
pHead = pHead.next;
}
return null;
扫一扫
4958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
