文章目录
21 合并两个有序双链表
题目
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
问题分析
双指针
两个链表都是有序的，因此，利用双指针，分别指向两个链表，比较大小，再定义一个指针，用来返回结果
下面直接通过代码来方便理解
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
// 特殊处理
if (list1 == nullptr) return list1;
if (list2 == nullptr) return list2;
// 结果指针
ListNode* ans = new ListNode(0);
// 遍历指针
ListNode* p = ans;
while (list1 != nullptr && list2 != nullptr) {
// 比较规则
if (list1->val < list2->val) {
p->next = list1; // 指针指向数值小的
list1 = list1->next; // 该链表下移
} else {
p->next = list2; // 否则指针指向数值大的
list2 = list2->next; // 该链表下移
}
p = p->next; // 结果指针下移
}
// 当一个链表结束后，结果指针直接指向另一个链表
if (list1 != nullptr) {
p->next = list1;
}
if (list2 != nullptr) {
p->next = list2;
}
// 结果指针定义的时候有头结点，因此返回头结点下一个地址
return ans->next;
}
};
递归
从上面的问题分析中可以知道，每次比较的问题基本类似，具有重叠子问题的结构，因此，本题也可以利用递归去求解。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
if (list1 == null) return list2;
else if (list2 == null) return list1;
// 比较规则
else if (list1.val < list2.val) {
// 递归， 递归的参数是l1的下一个地址，即已经排好序了一个元素，
// 将剩下的元素继续和l2进行比较
list1.next = mergeTwoLists(list1.next, list2);
// 确定了第一个元素在l1中，则返回l1
return list1;
} else {
// 同上
list2.next = mergeTwoLists(list1, list2.next);
// 确定了第一个元素在l2中，则返回l2
return list2;
}
}
}
83 删除排序链表中的重复元素
给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
示例 1：
输入：head = [1,1,2]
输出：[1,2]
示例 2：
输入：head = [1,1,2,3,3]
输出：[1,2,3]
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
问题分析
删除重复元素，最简单地方式就是利用定义两个指针，一前一后，如果两个指针指向的值相等，则让后指针的next指向前指针的下一个结点，然后再进行比较，如果还想等，就在前移，直到为null
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
// 空链表直接返回
if (head == nullptr) return head;
ListNode* cur = head;
// 循环条件为遍历指针的next指针不为空
while (cur->next != nullptr) {
// 当前指针指向的值和下一个结点的值进行比较
if (cur->val == cur->next->val) {
// 相同就跳过下一个结点，指向下下个结点
cur->next = cur->next->next;
} else {
// 不相同就令遍历指针下移
cur = cur->next;
}
}
// 返回头结点
return head;
}
};
递归
仔细观察，可以看出来，算法的核心步骤就是在进行两个结点之间的比较，所以具有重复子问题的结构
因此，可以用递归来求解
图中黄色箭头指向的链表就是最后的结果
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
// 链表为空就返回
if (head == null || head.next == null) return head;
// 调用递归
head.next = deleteDuplicates(head.next);
// 比较当前结点和下一个结点的值，相等就跳过，返回下下个结点
return head.val == head.next.val ? head.next : head;
}
}
141. 环形链表
题目
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
提示：
链表中节点的数目范围是 [0, 104]
−
1
0
5
<
=
N
o
d
e
.
v
a
l
<
=
1
0
5
-10^5 <= Node.val <= 10^5
−105<=Node.val<=105
pos 为 -1 或者链表中的一个 有效索引 。
问题分析
这道题就是判断链表是否形成了环
利用Floyd算法，建立快慢双指针就可以轻松解决问题了
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
// Floyd 算法 快慢双指针
public boolean hasCycle(ListNode head) {
if (head == null) return false;
// 定义快慢指针
ListNode slowPtr = head, fastPtr = head;
// 利用快指针作为边界条件
while (fastPtr.next != null && fastPtr.next.next != null) {
slowPtr = slowPtr.next; // 慢指针一次走一步
fastPtr = fastPtr.next.next; // 快指针一次走两步
if (slowPtr == fastPtr) { // 如果相遇说明有环
return true;
}
}
return false;
}
}
142. 环形链表II
题目
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
提示：
链表中节点的数目范围在范围
[
0
,
1
0
4
]
[0, 10^4]
[0,104]内
−
1
0
5
<
=
N
o
d
e
.
v
a
l
<
=
1
0
5
-10^5 <= Node.val <= 10^5
−105<=Node.val<=105
pos 的值为 -1 或者链表中的一个有效索引
问题分析
这道是环形链表的变形，在原有判断是否有环的条件下，增加了返回环的第一个节点。
那么思路就是先判断是否有环，然后再去找环中的第一个节点
判断是否有环，直接使用上面的方法，建立快慢双指针，相遇即有环
在相遇的条件下，令慢指针重新指向头节点，并且让两个指针每次都只移动一个节点，这样，两个指针相遇的结点就一定是环中的第一个节点，不然就不会相遇，这里可以自己建个样例画一下
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
// 在环形链表1的基础上
// 先找出是否有环，有环在进行下一步操作，无环则直接返回
public ListNode detectCycle(ListNode head) {
if (head == null) return head;
// 快慢双指针
ListNode slow = head, fast = head;
boolean hasCircle = false; // 记录是否有环
while (fast.next != null && fast.next.next != null) {
fast = fast.next.next;
slow = slow.next;
if (fast == slow) {
hasCircle = true;
break;
}
}
// 有环
if (hasCircle) {
slow = head; // 慢指针重新指向head
while (fast != slow) {
// 快慢指针都只走一步
fast = fast.next;
slow = slow.next;
}
// 相遇的结点就是环的第一个结点
return slow;
}
// 无环返回null
return null;
}
}
160.相交链表
题目
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
自定义评测：
评测系统 的输入如下（你设计的程序 不适用 此输入）：
- intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
- listA - 第一个链表
- listB - 第二个链表
- skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
- skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
- listA 中节点数目为 m
- listB 中节点数目为 n
- 1 < = m , n < = 3 ∗ 1 0 4 1 <= m, n <= 3 * 10^4 1<=m,n<=3∗104
- 1 < = N o d e . v a l < = 1 0 5 1 <= Node.val <= 10^5 1<=Node.val<=105
- 0 < = s k i p A < = m 0 <= skipA <= m 0<=skipA<=m
-
0
<
=
s
k
i
p
B
<
=
n
0 <= skipB <= n
0<=skipB<=n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]
问题分析
双指针
通过设立两个指针，如果相交，那么一定会相遇
方法一 ： 双指针交换指向，寻找交点
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
// 预防
if (headA == null) return null;
if (headB == null) return null;
// 双指针
ListNode slow = headA, fast = headB;
while (slow != fast) {
// 如果慢指针指向的链表遍历完了，就遍历B
slow = slow == null ? headB : slow.next;
// 同样，快指针指向A, 交换指向可以提升遍历速度
fast = fast == null ? headA : fast.next;
}
// 相交则slow不为空，不想交，slow就为null
return slow;
}
使链表从相同长度开始遍历
如果两个链表不一样长，那么就让长链表从和短链表相同长度开始，然后两个链表同时遍历，如果相交，那么就会相遇，否则不相交
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null) return null;
if (headB == null) return null;
int lenA = 0; // A表长度
int lenB = 0; // B表长度
ListNode pa = headA;
ListNode pb = headB;
// 求出两个链表之间相差的长度，然后令长链表减去差，使两个链表从相同的长度开始遍历，如果相交，则返回，不想交，返回null
while (pa != null) {
lenA++;
pa = pa.next;
}
while (pb != null) {
lenB++;
pb = pb.next;
}
// 比较链表，令长链表指针向后移动 |lenA - lenB| 个长度
if (lenA > lenB) {
lenA = lenA - lenB;
pa = headA;
pb = headB;
for (int i = 0; i < lenA; i++) {
pa = pa.next;
}
} else {
lenB = lenB - lenA;
pb = headB;
pa = headA;
for (int i = 0; i < lenB; i++) {
pb = pb.next;
}
}
while (pa != null) {
if (pa == pb) { // 相遇
break;
} else {
pa = pa.next;
pb = pb.next;
}
}
return pa;
}
206.反转链表
题目
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
问题分析
这道题就是让原本链表的指向变成逆向的，所以可以直接建立几个指针，在遍历链表的同时，将 next 指向变换方向
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
// 双指针
public ListNode reverseList(ListNode head) {
if (head == null) return head;
ListNode preNode = null;
ListNode cur = head;
ListNode ptr = head;
while (cur != null) {
// 保存下一个结点
ptr = cur.next;
// 当前结点指针指向前一个结点
cur.next = preNode;
// 指针往下移
preNode = cur;
cur = ptr;
}
// 最后的结点作为头指针返回
return preNode;
}
}
234.回文链表
题目
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：head = [1,2,2,1]
输出：true
示例 2：
输入：head = [1,2]
输出：false
提示：
链表中节点数目在范围
[
1
,
1
0
5
]
[1, 10^5]
[1,105]内
0 <= Node.val <= 9
问题分析
回文：即头和尾的元素时相同的
既然头和尾的数值相同，那么就去定义两个指针分别从头和尾进行遍历，如果数值都相同，那么就是回文的，反之，不是回文链表
从尾向前遍历，那么就需要将后半部分的节点指针反向，这里就用到了反转链表的知识
这里说一下如何找到需要进行反转链表的头结点
首先分为两种情况，分别是链表节点个数是奇数个和偶数个，下面分别展示
这里让奇数个数的链表的中间节点归前部分
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public boolean isPalindrome(ListNode head) {
// 预防
if (head == null) return false;
ListNode ptr = head;
ListNode slow = head;
ListNode fast = head;
// 快慢指针
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
// 判断链表个数奇偶性，奇 fast != null, 偶 fast = null
if (fast != null) {
slow = slow.next; // 将奇数个链表的中间结点归为左边
}
// 反转右边链表
ListNode tail = reverse(slow);
// 两边向中间进行比较
fast = head;
while (tail != null) {
// 如果不相等，则不是回文
if (fast.val != tail.val) return false;
tail = tail.next;
fast = fast.next;
}
return true;
}
// 反转链表
public ListNode reverse(ListNode head) {
if (head == null) return head;
ListNode cur = head;
ListNode pre = null;
while (cur != null) {
// 保存下一个节点
ListNode next = cur.next;
// 反向
cur.next = pre;
// 指针下移
pre = cur;
cur = next;
}
return pre;
}
}
