题目汇总https://leetcode-cn.com/tag/linked-list/
剑指 Offer 18. 删除链表的节点简单[✔]
剑指 Offer 22. 链表中倒数第k个节点简单[✔]
剑指 Offer 24. 反转链表简单[✔]
剑指 Offer 35. 复杂链表的复制中等[✔]
剑指 Offer 52. 两个链表的第一个公共节点简单[✔]
面试题 02.01. 移除重复节点简单[✔]
面试题 02.02. 返回倒数第 k 个节点简单[✔]
面试题 02.03. 删除中间节点简单 [✔]
面试题 02.04. 分割链表中等（没看懂题目什么意思，和86题的分割链表好像一样又不一样）
面试题 02.05. 链表求和中等[✔]
面试题 02.06. 回文链表简单[✔]
面试题 02.07. 链表相交简单[✔]
面试题 02.08. 环路检测中等[✔]
注：这一页的题目基本都做过两三遍了。
剑指 Offer 18. 删除链表的节点简单[✔]
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。
注意：此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明：
- 题目保证链表中节点的值互不相同
- 若使用 C 或 C++ 语言，你不需要
free或delete被删除的节点
思路：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户,//2020/08/07
public ListNode deleteNode(ListNode head, int val) {
if(head == null) return null;
if(head.val == val) return head.next;
ListNode pre = head;
ListNode cur = head.next;
while(cur != null){
if(cur.val == val){
pre.next = cur.next;
}
pre = cur;
cur = cur.next;
}
return head;
}
}
剑指 Offer 22. 链表中倒数第k个节点简单[✔]
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
思路：双指针
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户，//2020/08/07
public ListNode getKthFromEnd(ListNode head, int k) {
if(head == null || k < 1) return null;
ListNode fast = head;
ListNode slow = head;
for(int i = 0; i < k - 1; i++){//前移k-1步
if(fast != null){
fast = fast.next;
}else{
return null;
}
}
while(fast.next != null){
fast = fast.next;
slow = slow.next;
}
return slow;
}
}
剑指 Offer 24. 反转链表简单[✔]
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
思路一：递归
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户,//2020/08/07
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode cur = reverseList(head.next);
head.next.next = head;
head.next = null;
return cur;
}
}
思路二：迭代
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户//2020/08/04
public ListNode reverseList(ListNode head) {
ListNode pre = null;//预先指针节点
ListNode cur = head;//当前指针节点
while(cur != null){
ListNode nextTmp = cur.next;//临时节点，暂存当前节点的下一节点，用于后移
cur.next = pre;//将当前节点指向它前面的节点
pre = cur;//前指针后移
cur = nextTmp;//当前指针后移
}
return pre;
}
}
剑指 Offer 35. 复杂链表的复制中等
请实现
copyRandomList函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个next指针指向下一个节点，还有一个random指针指向链表中的任意节点或者null。
示例 1：
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2：
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]
示例 3：
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]
示例 4：
输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。
提示：
(1)-10000 <= Node.val <= 10000
(2)Node.random为空（null）或指向链表中的节点。
(3)节点数目不超过 1000 。
与 138. 复制带随机指针的链表相同
思路：
1.复制每个节点，追加到原来的每个节点中
2.复制random
3.分割原链表和复制的链表
/*
// Definition for a Node.
class Node {
int val;
Node next;
Node random;
public Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户，//2020/08/07
public Node copyRandomList(Node head) {
if(head == null) return null;
Node cur = head;
while(cur != null){
Node copy = new Node(cur.val, cur.next, cur.random);
copy.next = cur.next;
cur.next = copy;
cur = copy.next;
}
cur = head;
while(cur != null){
if(cur.random != null){
cur.next.random = cur.random.next;
}
cur = cur.next.next;
}
Node node = head;
Node newHead = head.next;
Node newNode = newHead;
while(node != null){
node.next = node.next.next;
if(newNode.next != null){
newNode.next = newNode.next.next;
}
node = node.next;
newNode = newNode.next;
}
return newHead;
}
}
剑指 Offer 52. 两个链表的第一个公共节点简单[✔]
输入两个链表，找出它们的第一个公共节点。
注意：
如果两个链表没有交点，返回null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
与160. 相交链表简单相同
思路一：
如果两个链表相交，那么他们一定有相同的尾结点，分别遍历两个链表，记录他们的尾结点，如果他们的尾结点相同，那么这两个表相交。分别计算两个链表的长度，先对链表head1遍历(len1-len2)(假设len1>len2)个结点到结点p，此时结点p与head2到他们相交的结点的距离相等。此时同时遍历两个链表，直到遇到相同的结点为止，这个结点就是交点。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {//执行用时：1 ms, 在所有 Java 提交中击败了100.00%的用户，2020/08/01
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == null || headB == null) return null;
int lenA = 1;
ListNode tailA = headA;
while(tailA.next != null){
tailA = tailA.next;
lenA++;//链表A的长度
}
int lenB = 1;
ListNode tailB = headB;
while(tailB.next != null){
tailB = tailB.next;
lenB++;//链表B的长度
}
if(tailA != tailB) return null;
ListNode nodeA = headA;
ListNode nodeB = headB;
if(lenA > lenB){
int d = lenA - lenB;
while(d != 0){
nodeA = nodeA.next;
d--;
}
}else{
int d = lenB - lenA;
while(d != 0){
nodeB = nodeB.next;
d--;
}
}
while(nodeA != nodeB){
nodeA = nodeA.next;
nodeB = nodeB.next;
}
return nodeA;
}
}
思路二：
也是为了消除长度差，但是代码更简洁
https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/tu-jie-xiang-jiao-lian-biao-by-user7208t/
指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
如果 pA 到了末尾，则 pA = headB 继续遍历
如果 pB 到了末尾，则 pB = headA 继续遍历
比较长的链表指针指向较短链表head时，长度差就消除了
如此，只需要将最短链表遍历两次即可找到位置
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) return null;
ListNode pA = headA, pB = headB;
while (pA != pB) {
pA = pA == null ? headB : pA.next;
pB = pB == null ? headA : pB.next;
}
return pA;
}
}
面试题 02.01. 移除重复节点简单[✔]
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。
示例1:
输入：[1, 2, 3, 3, 2, 1]
输出：[1, 2, 3]
示例2:
输入：[1, 1, 1, 1, 2]
输出：[1, 2]
提示： 链表长度在[0, 20000]范围内。链表元素在[0, 20000]范围内。
进阶：如果不得使用临时缓冲区，该怎么解决？
思路一：HashSet，使用临时缓冲区
从链表的头开始遍历，如果在set集合中有出现重复的元素，我们直接过滤掉，指向下一个节点。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：7 ms, 在所有 Java 提交中击败了40.42%的用户,//2020/08/07
public ListNode removeDuplicateNodes(ListNode head) {
HashSet set = new HashSet<>();
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode pre = dummy;
while(pre.next != null){
if(set.contains(pre.next.val)){
pre.next = pre.next.next;
}else{
set.add(pre.next.val);
pre = pre.next;
}
}
return dummy.next;
}
}
思路二：双指针，不使用临时缓冲区
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：358 ms, 在所有 Java 提交中击败了17.66%的用户,//2020/08/07
public ListNode removeDuplicateNodes(ListNode head) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode pre = dummy;
while(pre.next != null){
ListNode cur = pre.next;
while(cur.next != null){
if(pre.next.val == cur.next.val){
cur.next = cur.next.next;
}else{
cur = cur.next;
}
}
pre = pre.next;
}
return dummy.next;
}
}
思路三：位运算（根本想不到，也没看懂）
https://leetcode-cn.com/problems/remove-duplicate-node-lcci/solution/javade-4chong-xie-fa-bao-gua-di-gui-wei-yun-suan-b/
面试题 02.02. 返回倒数第 k 个节点简单[✔]
实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。
注意：本题相对原题稍作改动
示例：
输入：1->2->3->4->5和k = 2
输出： 4
说明：给定的 k 保证是有效的。
与剑指 Offer 22. 链表中倒数第k个节点类似，只是返回值不同
思路：双指针
设置一个快指针和一个慢指针，快指针比慢指针先向前移 k - 1 步，然后两个指针同时向前移动。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户,//2020/08/07
public int kthToLast(ListNode head, int k) {
if(head == null || k < 1) return -1;
ListNode fast = head;
ListNode slow = head;
for(int i = 0; i < k - 1; i++){//前移k-1步
if(fast != null){
fast = fast.next;
}else{
return 0;
}
}
while(fast.next != null){
fast = fast.next;
slow = slow.next;
}
return slow.val;
}
}
面试题 02.03. 删除中间节点简单 [✔]
实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。
示例：
输入：单向链表a->b->c->d->e->f中的节点c
结果：不返回任何数据，但该链表变为a->b->d->e->f
思路：
要理解函数中的参数node，删除的节点不是首尾节点，但不一定是最中间的那个节点。因此将当前节点的值改为下一个节点的值，将当前节点的next指向下一个next的指向。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户,//2020.08/07
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
面试题 02.04. 分割链表中等
编写程序以 x 为基准分割链表，使得所有小于 x 的节点排在大于或等于 x 的节点之前。如果链表中包含 x，x 只需出现在小于 x 的元素之后(如下所示)。分割元素 x 只需处于“右半部分”即可，其不需要被置于左右两部分之间。
示例:
输入: head = 3->5->8->5->10->2->1, x = 5
输出: 3->1->2->10->5->5->8
思路：
个人认为这个题目和 86. 分隔链表是一样的，但是运行测试用例又不一样，可是一样的代码却提交通过了。还是不太理解题目，会做86题的分割链表得了。
面试题 02.05. 链表求和中等[✔]
给定两个用链表表示的整数，每个节点包含一个数位。
这些数位是反向存放的，也就是个位排在链表首部。
编写函数对这两个整数求和，并用链表形式返回结果。
示例：
输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912
与 2. 两数相加样，给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
思路：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：2 ms, 在所有 Java 提交中击败了100.00%的用户，//2020/08/07
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode pre = new ListNode(0);
ListNode cur = pre;
int carry = 0;
while(l1 != null || l2 != null){
int x = (l1 == null ? 0 : l1.val);
int y = (l2 == null ? 0 : l2.val);
int sum = x + y + carry;
carry = sum / 10; // 进位值
cur.next = new ListNode(sum % 10);//实际存入链表的值
cur = cur.next;
if(l1 != null) l1 = l1.next;
if(l2 != null) l2 = l2.next;
}
if(carry == 1){//最后一位相加，是否还需要进位
cur.next = new ListNode(carry);
}
return pre.next;
}
}
进阶：假设这些数位是正向存放的，请再做一遍。
示例：
输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
输出：9 -> 1 -> 2，即912
与 445. 两数相加 II一样，给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
思路：栈
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：5 ms, 在所有 Java 提交中击败了63.13%的用户，2020/08/05
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
Stack stack1 = new Stack<>();
Stack stack2 = new Stack<>();
while(l1 != null){
stack1.push(l1.val);
l1 = l1.next;
}
while(l2 != null){
stack2.push(l2.val);
l2 = l2.next;
}
int carry = 0;//进位值
ListNode pre = null;//设置预先指针
while(!stack1.isEmpty() || !stack2.isEmpty() || carry > 0){
int sum = carry;
sum += stack1.isEmpty()? 0:stack1.pop();
sum += stack2.isEmpty()? 0:stack2.pop();
ListNode node = new ListNode(sum % 10);//实际存入链表的值
node.next = pre;
pre = node;
carry = sum / 10;
}
return pre;
}
}
面试题 02.06. 回文链表简单[✔]
编写一个函数，检查输入的链表是否是回文的。
示例 1：
输入： 1->2，输出： false
示例 2：
输入： 1->2->2->1，输出： true
进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
与 234. 回文链表一样
思路：
找到中点，反转后半部分，再比较。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {//执行用时：1 ms, 在所有 Java 提交中击败了99.70%的用户，2020/08/04
public boolean isPalindrome(ListNode head) {
if (head == null || head.next == null)
return true;
ListNode slow = head;
ListNode fast = head;
// 根据快慢指针，找到链表的中点
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
ListNode newHalf = reverse(slow);
while(newHalf != null){// 两个半长链表的比较 遍历两个半长链表
if(head.val != newHalf.val){
return false;
}
newHalf = newHalf.next;
head = head.next;
}
return true;
}
//206题反转链表
private ListNode reverse(ListNode head) {
// 递归到最后一个节点，返回新的新的头结点
if (head.next == null) {
return head;
}
ListNode newHead = reverse(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
}
面试题 02.07. 链表相交简单[✔]
给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。
示例 ：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
注意：
如果两个链表没有交点，返回 null 。
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
思路一：
如果两个链表相交，那么他们一定有相同的尾结点，分别遍历两个链表，记录他们的尾结点，如果他们的尾结点相同，那么这两个表相交。分别计算两个链表的长度，先对链表head1遍历(len1-len2)(假设len1>len2)个结点到结点p，此时结点p与head2到他们相交的结点的距离相等。此时同时遍历两个链表，直到遇到相同的结点为止，这个结点就是交点。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {//执行用时：1 ms, 在所有 Java 提交中击败了100.00%的用户，2020/08/01
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == null || headB == null) return null;
int lenA = 1;
ListNode tailA = headA;
while(tailA.next != null){
tailA = tailA.next;
lenA++;//链表A的长度
}
int lenB = 1;
ListNode tailB = headB;
while(tailB.next != null){
tailB = tailB.next;
lenB++;//链表B的长度
}
if(tailA != tailB) return null;
ListNode nodeA = headA;
ListNode nodeB = headB;
if(lenA > lenB){
int d = lenA - lenB;
while(d != 0){
nodeA = nodeA.next;
d--;
}
}else{
int d = lenB - lenA;
while(d != 0){
nodeB = nodeB.next;
d--;
}
}
while(nodeA != nodeB){
nodeA = nodeA.next;
nodeB = nodeB.next;
}
return nodeA;
}
}
思路二：
也是为了消除长度差，但是代码更简洁
https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/tu-jie-xiang-jiao-lian-biao-by-user7208t/
指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
如果 pA 到了末尾，则 pA = headB 继续遍历
如果 pB 到了末尾，则 pB = headA 继续遍历
比较长的链表指针指向较短链表head时，长度差就消除了
如此，只需要将最短链表遍历两次即可找到位置
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) return null;
ListNode pA = headA, pB = headB;
while (pA != pB) {
pA = pA == null ? headB : pA.next;
pB = pB == null ? headA : pB.next;
}
return pA;
}
}
面试题 02.08. 环路检测中等[✔]
给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。
有环链表的定义：在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。
进阶：你是否可以不用额外空间解决此题？
思路：双指针
与上一题相比，情况复杂一些，不仅判断是否有环，还要找到环的入口节点。
在链表头与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {//执行用时 :0 ms, 在所有 Java 提交中击败了100.00%的用户，2020/08/05
public ListNode detectCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if(fast == slow) break;
}
if(fast == null || fast.next == null) return null;
slow = head;
while(fast != slow){
fast = fast.next;
slow = slow.next;
}
return slow;
}
}