算法学习打卡day4｜合并两个有序链表、合并k个有序链表、19.删除链表的倒数第N个节点、寻找单链表的中点、链表相交、142.环形链表II

合并两个有序链表

力扣题目链接
题目描述：
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：
输入：l1 = [], l2 = []
输出：[]
思路：

• 两种方法：迭代法和递归法
• 迭代法：
  • 建立一个虚拟头节点，两个链表同时遍历，每次遍历都比较下每个节点的值，值小的接在虚拟头节点后，直到有一个链表为空推出循环，然后把非空的链表接在新链表后即可。
• 递归法：
  • 思路：每次递归都判断两个链表的值，让值小的一个链表（比如list1）的下一个节点和 list2 去递归调用本函数，list1的指针域存储函数返回值，这样相当于list指向的是已经合并好的新链表，最后直接返回list1即可。
  • 递归结束条件：两个链表其中一个为空时，返回另一个链表
  • 递归法不需要进入递归函数，只要做好两件事，第一是什么时候结束递归， 显然本题结束条件就是list1或list2为空的时候（都为空了还合并个啥？），然后返回后直接就接到了上次递归较小的节点后了。第二是本次递归函数需要做的事，本题要做的就是判断两个链表当前节点的值的大小，将较小的节点留下，然后剩下的节点交给递归函数就行了（让递归函数帮我们去进行剩下节点的合并），我们只关注本次递归要做的事情。

迭代法实现：

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* virtual_node = new ListNode(0, nullptr);
        ListNode* cur_node = virtual_node;
        while(list1 && list2) {
            if (list1->val > list2->val) {
                cur_node->next = list2;
                list2 = list2->next;
            } else {
                cur_node->next = list1;
                list1 = list1->next;
            }
            cur_node = cur_node->next;
        }
        cur_node->next = list1 == nullptr ? list2 : list1;
        cur_node = virtual_node->next;
        delete virtual_node;
        return cur_node;
    }

递归法实现：

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (list1 == nullptr) {
            return list2;
        } 
        if (list2 == nullptr) {
            return list1;
        }
        if (list1->val > list2->val) {
            list2->next = mergeTwoLists(list1, list2->next);
            return list2;
        } else {
            list1->next = mergeTwoLists(list1->next, list2);
            return list1;
        }
    }

合并k个有序链表

力扣题目链接
题目描述：
给定一个链表数组，每个链表都已经按升序排列。请将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
思路：

• 迭代法两两顺序合并，遍历数组链表，然后两两合并（合并逻辑看上题）即可。
• 采用优先级队列
  • 思路：把每个链表都存入优先级队列，每次取出头节点最小的链表的第一个元素，然后将其下一个节点做为新的链表存到优先级队列，直到优先级队列为空，这样就得到了升序的新链表。
  • 由于是自定义类型，需要定义一个结构体重载比较函数，实现比较函数。

迭代法代码如下：

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* virtual_node = new ListNode(0);
        ListNode* cur_node = virtual_node;
        while(list1 && list2) {
            if (list1->val > list2->val) {
                cur_node->next = list2;
                list2 = list2->next;
            } else {
                cur_node->next = list1;
                list1 = list1->next;
            }
            cur_node = cur_node->next;
        }
        cur_node->next = list1 == nullptr ? list2 : list1;
        cur_node = virtual_node->next;
        delete virtual_node;
        return cur_node;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.empty()) {
            return nullptr;
        }
        ListNode* head = nullptr;
        for (int i = 0; i < lists.size(); ++i) {
            head = mergeTwoLists(head, lists[i]);
        }
        return head;
    }

优先级队列法代码如下：

struct comparison {
        bool operator () (ListNode* list1, ListNode* list2) {
            return list1->val > list2->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode*>, comparison> pri_que;
        for (ListNode*& list : lists) {
            if (list)   pri_que.push(list);
        }
        ListNode* virtual_node = new ListNode(0);
        ListNode* cur = virtual_node;
        while (!pri_que.empty()) {
            ListNode* top = pri_que.top();
            pri_que.pop();
            cur->next = top;
            cur = cur->next;
            if (top->next) {
                pri_que.push(top->next);
            }
        }
        ListNode* head = virtual_node->next;
        return head;
    }

19.删除链表的倒数第N个节点

力扣题目链接
题目描述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

思路：

• 利用双指针法，因为要删除元素，所以需要找到所删除元素的上一个元素，那么其实相当于找到倒数第N+1个元素，所以让fast指针先走n + 1步，然后快慢指针同时走，当fast走到结尾时，slow即为插入点的前一个位置（因为插入元素需要找到链表前一个位置）
• 因为要插入元素，所以继续使用虚拟头节点

代码实现

ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* virtual_node = new ListNode(0, head);
        ListNode* fast = virtual_node, *slow = virtual_node;
        //fast先走n+1步
        for(int i = 0; i < n + 1; ++i) {
            fast = fast->next;
        }
        //fast和slow同时走，知道fast走到末尾
        while(fast) {
            fast = fast->next;
            slow = slow->next;
        }
        //执行删除
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        head = virtual_node->next;
        delete virtual_node;//释放
        return head;
    }

链表相交

力扣题目链接
题目描述：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构
例如：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

思路：

• 分别求出两个链表的长度，求出长度差值len，然后让长的一个先走len步，之后两个链变同时遍历，遇到相交节点返回即可。

代码实现

int get_len(ListNode* head) {
        int len = 0;
        while(head) {
            head = head->next;
            len++;
        }
        return len;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA = get_len(headA);
        int lenB = get_len(headB);
        int len = abs(lenA - lenB);
        if (lenA > lenB) {
            while(len--) {
                headA = headA->next;
            }
        } else {
            while(len--) {
                headB = headB->next;
            }
        }
        while(headA && headB) {
            if (headA == headB) {
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
        }
        return NULL;
    }

寻找单链表的中点

力扣题目链接
题目描述：
给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：head = [1,2,3,4,5]
输出：[3,4,5]
解释：链表只有一个中间结点，值为 3 。

思路：

• 普通方法就是求链表长度，然后第二次遍历直接访问N/2位置元素就行。
• 双指针法，快慢指针法，快指针走两步，慢指针走一步，当快指针走到末尾时，慢指针刚好走到中间位置。
  • 对于奇数偶数问题，如果链表节点数为奇数时，最后一次，fast一定走到了 N的位置，而此时一共走了（N - 1）/ 2 次，此时slow刚好是中间位置，如 N = 3，那么fast只走了一次走两步刚好到了第三个位置，而此时slow走一步到了第二个位置也就是中间位置。
  • 对于偶数时，最后一次，fast一定走到了N的下一位置，此时一共走了 N / 2 次，而此时slow也在中间位置，如 N = 4，fast走了2次，4步 走到了第五个位置（此时为空），而slow走了2次，2步，走了第三个位置，刚好是题目所说的中间位置的第二个元素。

代码实现：

ListNode* middleNode(ListNode* head) {
        ListNode* fast = head, *slow = head;
        while(fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }

142.环形链表II

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

思路：

• 定义两个指针 fast 和 slow ，fast走两步，slow走一步，若有环则一定可以相遇，设head到环入口为x，入口到相遇点为y，相遇点到环入口为z，则有：2 * （x + y）= x + y + n（y + z），化简完后为：x = （n - 1）*（y + z） + z，则此时定义一个index1处于head处，index2处于相遇点处，两者同时往前走，相遇点就是环的入口，因为index2相当于走了（n - 1）圈外加Z步。
• 为什么相遇点一定在slow入环的第一圈？
  • 因为当slow入环时，fast一定在先入环，然后slow如果下次走到环入口的时候，fast一定走了两圈，所以两者必然会在中间相遇，而slow根本走不完一圈。

解题步骤：

1. fast和slow同时向前走，找到相遇点
2. 在相遇点定义一个指针index2，在起点定义一个指针index1，两者同时走相遇点即为环的入口。

代码实现：

ListNode *detectCycle(ListNode *head) {
        if (head == nullptr || head->next == nullptr) {
            return nullptr;
        }
        ListNode* fast = head, *slow = head;
        while (fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* index2 = fast;
                ListNode* index1 = head;
                while(index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
    }

链表题目经验总结

• 遇到相似步骤，比如：两两交换链表、反转链表、合并有序链表、k个链表反转，可以考虑用递归法，更简单些。