算法学习打卡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 NewNode {
int val;
ListNode* cur;
bool operator < (const NewNode& node1) const {
return val > node1.val;
}
};
priority_queue<NewNode, vector<NewNode>, less<NewNode>> pre_que;//全局优先级队列
ListNode* mergeKLists(vector<ListNode*>& lists) {
if (lists.empty()) {
return nullptr;
}
ListNode* virtual_node = new ListNode(0, nullptr);
//造堆
for (auto& list : lists) {
if (list) {
pre_que.push({list->val, list});
}
}
//遍历优先级队列，依次找出最小值
ListNode* cur_node = virtual_node;
while(!pre_que.empty()) {
auto top_node = pre_que.top();
pre_que.pop();
cur_node->next = top_node.cur;
cur_node = cur_node->next;
if (top_node.cur->next) {
pre_que.push({top_node.cur->next->val, top_node.cur->next});
}
}
ListNode* head = virtual_node->next;
return head;
}
19.删除链表的倒数第N个节点
力扣题目链接
题目描述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
思路：
- 利用双指针法，fast指针先走n + 1步，然后快慢指针同时走，当fast走到结尾时，即为插入点的前一个位置（因为插入元素需要找到链表前一个位置）
- 因为要插入元素，所以继续使用虚拟头节点
代码实现
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根本走不完一圈。
解题步骤：
- fast和slow同时向前走，找到相遇点
- 在相遇点定义一个指针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;
}