【leetcode】链表相关题目思路总结（更新中）

简单题

206. 反转链表

剑指 Offer 24. 反转链表

https://leetcode-cn.com/problems/reverse-linked-list/https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/submissions/

题目描述：
反转链表。

解题思路：
借助几个临时指针。一个prev，一个curr，一个temp，然后不断做赋值互换即可。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        ListNode* temp;
        while(curr) {
            temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
};

21. 合并两个有序链表

https://leetcode-cn.com/problems/merge-two-sorted-lists/

题目描述：
合并两个有序链表。

解题思路：
比较两个链表的头指针的val大小，然后不断串联起来。

代码：

/**
 * 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* l1, ListNode* l2) {
        ListNode rst(0);
        ListNode* temp = &rst;
        while(l1 && l2) {
            if (l1->val < l2->val) {
                temp->next = l1;
                l1 = l1->next;
            } else {
                temp->next = l2;
                l2 = l2->next;
            }
            temp = temp->next;
        }
        if (l1) {
            temp->next = l1;
        }
        if (l2) {
            temp->next = l2;
        }
        return rst.next;
    }
};

面试题 02.07. 链表相交

剑指 Offer 52. 两个链表的第一个公共节点

160. 相交链表

https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/https://leetcode-cn.com/problems/intersection-of-two-linked-lists/

题目描述：
两个长度不同的链表，从某个节点开始相交，后面的都是一样的。

解题思路：
先将两个链表长度对齐，然后遍历比较，找到的第一个一样的就是所求。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int len_list1 = 0;
        int len_list2 = 0;
        ListNode* tempA;
        ListNode* tempB;
        tempA = headA;
        while(tempA) {
            tempA = tempA->next;
            len_list1 += 1;
        }
        tempB = headB;
        while(tempB) {
            tempB = tempB->next;
            len_list2 += 1;
        }

        tempA = headA;
        tempB = headB;
        while (len_list2 < len_list1) {
            tempA = tempA->next;
            len_list1 -= 1;
        }
        while(len_list1 < len_list2) {
            tempB = tempB->next;
            len_list2 -= 1;
        }

        for (int i = 0; i < len_list1; i++) {
            if (tempA == tempB) {
                return tempA;
            }
            tempA = tempA->next;
            tempB = tempB->next;
        }
        return nullptr;
    }
};

面试题 02.01. 移除重复节点

https://leetcode-cn.com/problems/remove-duplicate-node-lcci/

题目描述：
将链表中的重复元素删除，并不改变链接顺序。

解题思路：
方法一，使用哈希表，时间空间复杂度均为O(n)。
方法二，循环遍历，时间复杂度O(n^2)，空间O(1)。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        set<int> data;
        ListNode* temp = head;
        ListNode* temp2 = new ListNode(0);
        ListNode* rst = temp2; 
        while(temp) {
            if (data.find(temp->val) == data.end()) {
                data.insert(temp->val);
                temp2->next = temp;
                temp2 = temp2->next;
            }
            temp = temp->next;
        }
        temp2->next = nullptr;
        return rst->next;
    }
};

剑指 Offer 22. 链表中倒数第k个节点

面试题 02.02. 返回倒数第k个节点

https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/https://leetcode-cn.com/problems/kth-node-from-end-of-list-lcci/

题目描述：
找出链表的倒数第k个节点。

解题思路：
用双指针，一个比另外一个快k步。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* fast;
        ListNode* slow;
        int i = 0;
        fast = head;
        slow = head;
        while(fast && i < k) {
            fast = fast->next;
            i++;
        }
        if (i < k) {
            return nullptr;
        }
        while(fast) {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

234. 回文链表

面试题 02.06. 回文链表

https://leetcode-cn.com/problems/palindrome-linked-list/https://leetcode-cn.com/problems/palindrome-linked-list-lcci/

题目描述：
判断链表是否对称。

解题思路：
方法一，将数据复制到数组中，然后双指针。
方法二，将后半部分链表反转，然后再遍历判断，之后再将后半部分恢复。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if (!head) {
            return true;
        }
        ListNode* fast;
        ListNode* slow;
        ListNode* prev;
        fast = head;
        slow = head;
        while(fast) {
            fast = fast->next;
            if (fast) {
                fast = fast->next;
            }
            prev = slow;
            slow = slow->next;
        }

        ListNode* save_ptr = reverseList(slow);
        ListNode* rev_ptr = save_ptr;
        ListNode* ptr = head;
        while(rev_ptr && ptr) {
            if (rev_ptr->val != ptr->val) {
                return false;
            }
            rev_ptr = rev_ptr->next;
            ptr = ptr->next;
        }

        ListNode* now_ptr = reverseList(save_ptr);
        prev->next = now_ptr;
        return true;
    }

    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        while(curr) {
            ListNode* temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
};

面试题 02.03. 删除中间节点

237. 删除链表中的节点

https://leetcode-cn.com/problems/delete-middle-node-lcci/https://leetcode-cn.com/problems/delete-node-in-a-linked-list/

题目描述：
删除链表中的某个节点。

解题思路：
假设链表为A->B->C->D，删除B，将B变为C即可，改变B的next，val。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

83. 删除排序链表中的重复元素

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/

题目描述：
删除链表中的重复元素。

解题思路：
判断当前节点和下一个节点的值是否相等，相等则将当前节点的next域直接指向下下个节点(就是丢掉下个节点)。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* rst = head;
        while(head && head->next) {
            if (head->val == head->next->val) {
                head->next = head->next->next;
            } else {
                head = head->next;
            }
        }
        return rst;
    }
};

剑指 Offer 06. 从尾到头打印链表

https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/

题目描述：
逆序打印链表值。

解题思路：
借助栈搞定。

代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        stack<int> data;
        vector<int> rst;
        while(head) {
            data.push(head->val);
            head = head->next;
        }
        while(!data.empty()) {
            rst.push_back(data.top());
            data.pop();
        }
        return rst;
    }
};

203. 移除链表元素

剑指 Offer 18. 删除链表的节点

https://leetcode-cn.com/problems/remove-linked-list-elements/https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/

题目描述：
删除链表中和给定值相同的元素。

解题思路：
因为头结点也可能会被删除，所以应当设置一个哨兵指针。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* pre = new ListNode(0);
        ListNode* save = pre;
        pre->next = head;
        while(pre->next) {
            if (pre->next->val == val) {
                pre->next = pre->next->next; 
            } else {
                pre = pre->next;
            }
        }
        return save->next;
    }
};

1474. 删除链表 M 个节点之后的 N 个节点

https://leetcode-cn.com/problems/delete-n-nodes-after-m-nodes-of-a-linked-list/

题目描述：
先保留M个，再删掉N个，再保留M个，再删掉N个，依次类推。

解题思路：
用哨兵节点，然后不断循环处理，直到链表末尾。

代码：

/**
 * 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* deleteNodes(ListNode* head, int m, int n) {
        ListNode* pre = new ListNode(0);
        pre->next = head;
        ListNode* save = pre;
        while(pre->next) {
            int temp_m = m;
            int temp_n = n;
            while(pre->next && temp_m > 0) {
                pre = pre->next;
                temp_m -= 1;
            }
            while(pre->next && temp_n > 0) {
                pre->next = pre->next->next;
                temp_n -= 1;
            }
        }
        return save->next;
    }
};

876. 链表的中间结点

https://leetcode-cn.com/problems/middle-of-the-linked-list/

题目描述：
求链表最中间的节点，如果有两个，则选择后面一个。

解题思路：
采用快慢指针法最好。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* fast = new ListNode(0);
        ListNode* slow = new ListNode(0);
        fast->next = slow->next = head;
        while(fast->next) {
            fast = fast->next;
            if (fast->next) {
                fast = fast->next;
                slow = slow->next;
            }
        }
        return slow->next;
    }
};

1290. 二进制链表转整数

https://leetcode-cn.com/problems/convert-binary-number-in-a-linked-list-to-integer/

题目描述：
用链表表示二进制的每位数字，要求转成10进制。

解题思路：
模拟题，遍历一遍，一边遍历一边转即可。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int getDecimalValue(ListNode* head) {
        int sum = 0;
        while(head) {
            sum = sum*2 + head->val;
            head = head->next;
        }
        return sum;
    }
};

141. 环形链表

https://leetcode-cn.com/problems/linked-list-cycle/

题目描述：
判断一个链表是否有环。

解题思路：
快慢指针法，如果快慢指针跑着跑着跑到同一个节点了，那么必然是有环。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = new ListNode(0);
        ListNode* slow = new ListNode(0);
        fast->next = head;
        slow->next = head;
        while(fast->next) {
            fast = fast->next;
            if (fast == slow) {
                return true;
            }
            if (fast->next) {
                fast = fast->next;
                slow = slow->next;
            }
        }
        return false;
    }
};

中等题

1669. 合并两个链表

https://leetcode-cn.com/problems/merge-in-between-linked-lists/

题目描述：
将其中一个链表删去一段，然后接上另外一个链表。

解题思路：
把握关键节点，两个连接处的左右两个节点，要加以保存，然后连接即可。

代码：

/**
 * 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* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
        ListNode* pre = new ListNode(0);
        pre->next = list1;
        ListNode* save = pre;
        ListNode* left;
        ListNode* right;
        int i = 0;
        while(pre->next) {
            if (i == a) {
                left = pre;
            }
            if (i == b) {
                right = pre->next->next;
            }
            i += 1;
            pre = pre->next;
        }
        left->next = list2;
        pre = new ListNode(0);
        pre->next = list2;
        while(pre->next) {
            pre = pre->next;
        }
        pre->next = right;
        return save->next;
    }
};

92. 反转链表 II

https://leetcode-cn.com/problems/reverse-linked-list-ii/

题目描述：
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

解题思路：
除了m和n位置的节点外，m-1和n+1位置的节点也要保存，这样的话，就退化为了简单版本的反转链表，最后接起来就可以了。
注意m-1为空的情况，即从第一个节点开始逆置。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        int change_len = n - m + 1; // 需要逆序的长度
        ListNode* result = head; // 最终返回
        // ... pre_head head ... 
        ListNode* pre_head = NULL; 
        while(head && --m) {
            pre_head = head;
            head = head->next;
        }
        // ... modify_list_tail head ...
        ListNode* modify_list_tail = head;
        ListNode* new_head = NULL;
        // head - next - -
        // new_head - - -
        while(head && change_len) {
            ListNode* next = head->next;
            head->next = new_head;
            new_head = head;
            head = next;
            change_len--;
        }
        modify_list_tail->next = head;
        if (pre_head) {
            // 并非从第一个节点开始逆序
            pre_head->next = new_head;
        } else {
            result = new_head;
        }
        return result;
    }
};

142. 环形链表 II

面试题 02.08. 环路检测

https://leetcode-cn.com/problems/linked-list-cycle-ii/https://leetcode-cn.com/problems/linked-list-cycle-lcci/

题目描述：
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

解题思路：
这道题和环形链表的简单题思路大体相同，只不过最后要返回入环点。
有两种方法，一是直接用set，二是用快慢指针。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        ListNode* meet = NULL;
        while(fast) {
            fast = fast->next;
            slow = slow->next;
            if (!fast) {
                return NULL;
            }
            fast = fast->next;
            if (fast == slow) {
                meet = fast;
                break;
            }
        }
        if (!meet) {
            return NULL;
        }
        while (head && meet) {
            if (head == meet) {
                return meet;
            }
            head = head->next;
            meet = meet->next;
        }
        return NULL;
    }
};

86. 分隔链表

面试题 02.04. 分割链表

https://leetcode-cn.com/problems/partition-list/https://leetcode-cn.com/problems/partition-list-lcci/

题目描述：
给你一个链表和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。
你应当保留两个分区中每个节点的初始相对位置。

解题思路：
模拟法，使用两个临时链表，分别保存比x大的，和比x小的，最后接起来就行。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode less_head(0);
        ListNode more_head(0);
        ListNode* less_ptr = &less_head;
        ListNode* more_ptr = &more_head;
        while(head) {
            if (head->val < x) {
                less_ptr->next = head;
                less_ptr = less_ptr->next;
            } else {
                more_ptr->next = head;
                more_ptr = more_ptr->next;
            }
            head = head->next;
        }
        less_ptr->next = more_head.next;
        more_ptr->next = NULL;
        return less_head.next;
    }
};

138. 复制带随机指针的链表

剑指 Offer 35. 复杂链表的复制

https://leetcode-cn.com/problems/copy-list-with-random-pointer/https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/

题目描述：
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

解题思路：
保存节点地址-序号的映射(map)，序号-节点地址的映射(vector)，遍历两遍，就完成了链表复制。注意其中random指针为空的情形加判断条件。

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        map<Node*, int> node_map;
        vector<Node*> node_vec;
        Node* ptr = head;
        int i = 0;
        while(ptr) {
            node_vec.push_back(new Node(ptr->val));
            node_map[ptr] = i;
            i++;
            ptr = ptr->next;
        }
        node_vec.push_back(0);
        ptr = head;
        i = 0;
        while(ptr) {
            node_vec[i]->next = node_vec[i+1];
            if (ptr->random) {
                node_vec[i]->random = node_vec[node_map[ptr->random]];
            }
            ptr = ptr->next;
            i++;
        }
        return node_vec[0];
    }
};

困难题

23. 合并K个升序链表

https://leetcode-cn.com/problems/merge-k-sorted-lists/

题目描述：
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。

解题思路：
方法一：暴力解法，依次合并链表，(n+n)+(n+2n)+...+[n+(k-1)n],时间复杂度为O(nk^2)，空间复杂度O(1)。
方法二：先放到vector里，排序，然后再构造链表，knlog(kn)+kn，时间复杂度O(knlogkn)，空间复杂度O(kn)。
方法三：两两合并，分治法。2nk/2+4nk/4+8nk/8+...,时间复杂度O(knlogk)，空间复杂度O(logk)，递归用到的栈空间。
方法四：使用优先级队列，始终维护k个数，每次取出最小值后，将其后的节点插入。时间复杂度O(kn*logk)，空间复杂度O(k)。

代码：

/**
 * 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* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0) {
            return NULL;
        }
        if (lists.size() == 1) {
            return lists[0];
        }
        if (lists.size() == 2) {
            return mergeTwoLists(lists[0], lists[1]);
        }
        int mid = lists.size() / 2;
        vector<ListNode*> lists_vec1;
        vector<ListNode*> lists_vec2;
        for (int i = 0; i < mid; i++) {
            lists_vec1.push_back(lists[i]);
        }
        for (int i = mid; i < lists.size(); i++) {
            lists_vec2.push_back(lists[i]);
        }
        ListNode* lists1 = mergeKLists(lists_vec1);
        ListNode* lists2 = mergeKLists(lists_vec2);
        return mergeTwoLists(lists1, lists2);
    }

    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode temp_head(0);
        ListNode* pre = &temp_head;
        while(list1 && list2) {
            if (list1->val < list2->val) {
                pre->next = list1;
                list1 = list1->next;
            } else {
                pre->next = list2;
                list2 = list2->next;
            }
            pre = pre->next;
        }
        if (list1) {
            pre->next = list1;
        }
        if (list2) {
            pre->next = list2;
        }
        return temp_head.next;
    }
};