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

合并两个有序链表

力扣题目链接
题目描述:
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
算法学习打卡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 开始相交:
算法学习打卡day4|合并两个有序链表、合并k个有序链表、19.删除链表的倒数第N个节点、寻找单链表的中点、链表相交、142.环形链表II_第2张图片
题目数据 保证 整个链式结构中不存在环。

注意,函数返回结果后,链表必须 保持其原始结构
例如:
算法学习打卡day4|合并两个有序链表、合并k个有序链表、19.删除链表的倒数第N个节点、寻找单链表的中点、链表相交、142.环形链表II_第3张图片

输入: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;
    }

你可能感兴趣的:(算法学习打卡,算法,学习,链表)