LeetCode剑指 Offer——多个单链表的问题的思路和代码

LeetCode剑指 Offer——多个单链表的问题

1. 剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
相关标签：链表 递归

解：
递归有点复杂，不看递归了

使用迭代，初次比较两个链表的第一个节点值大小，哪个小就把这个节点加进去，然后这个链表的指针后移一位

1. 构造出一个只包含头结点的空链表，用来拼接这两个链表，而且便于返回
2. 根据两个链表的头指针比较大小

• 若la小，将小的连接上新链表，再将la链表的指针后移；
• 若lb小，将小的连接上新链表，再将lb链表的指针后移；

3. 多了一个节点，将新链表的指针后移；
4. 一直到某一个链表为空为止，那么另一个链表剩下的节点值都比较大，直接将剩下的那部分连接上新链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    //构造一个节点充当合并后的头结点，方便返回
    struct ListNode* q = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* p = q;//定义头指针，最后返回的就是头指针的next
    while(l1!=NULL && l2!=NULL){
        if(l1->val<=l2->val){
            p->next = l1;
            l1 = l1->next;
        }else{
            p->next = l2;
            l2 = l2->next;
        }
        p = p->next;
    }
    if(l1==NULL){//l1为空了，那么l2可能的剩余元素一定都比连接好的元素都大，直接连上即可
        p->next = l2;
    }
    if(l2==NULL){
        p->next = l1;
    }
    return q->next;
}

2. 剑指 Offer II 023. 两个链表的第一个重合节点

== 剑指 Offer 52. 两个链表的第一个公共节点
链接：https://leetcode.cn/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof

给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

示例 1：

输入：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 个节点。

示例 2：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。
相关标签：链表 双指针 哈希表

解：
（可以使用哈希表，不会用）
这个链表就是这样一个结构，重合部分应该只有一份。
如果两个链表的指针指向相同了，那么就是第一个相交节点

规律：a、b同时往后移1位

• 当a移到末尾时，a去指向b的头部；
• 当b移到末尾时，b去指向a的头部；

这样，在到达第一个节点时，a移动了a+(b-c)，b移动了b+(a-c)，a+(b-c) = b+(a-c)
如果没有公共节点，那么a、b不会相遇，a、b都为空

1. 先判断两个链表是否为空，有一个为空，就直接返回NULL
2. 定义指针保存两个链表的第一个节点以便于移动。
3. 两个链表的指针指向不同就进行迭代，链表指针如果不为空，每次后移一位，否则指向空就转到另一个链表的头部
4. 直到两链表指针指向相同
   • 有公共节点就指向公共节点
   • 没有就指向NULL
     

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
        //a+(b-c)  ==  b+(a-c)
    if(headA==NULL||headB==NULL)
        return NULL;
    struct ListNode* a = headA;
    struct ListNode* b = headB;
    while(a!=b){//两个指针指向不同,a、b可能指向空，不能比较数据域
        if(a==NULL){
            a = headB;
        }else{
            a = a->next;
        }

        if(b==NULL){
            b = headA;
        }else{
            b = b->next;
        }
    }

    return a;
}