每日一题（4.10）

Leecode-160-相交链表

题目

你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

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

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

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

示例

示例1

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例2

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

示例3

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

解题思路

1. 定义两个分别指向传入的两个头节点headA和headB的临时指针skipA和skipB
2. 遍历，记录两个链表的节点数量
3. 比较两个节点数量，遍历节点数多的那个头指针，直至两个链表剩余节点数相同
4. 循环遍历，找到相交节点，返回即可

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* skipA = headA;
    struct ListNode* skipB = headB;
    int cntA = 0, cntB = 0;
    while(skipA){
        skipA = skipA->next;
        cntA++;
    }
    while(skipB){
        skipB = skipB->next;
        cntB++;
    }
    if(cntA > cntB){
        while(cntA > cntB){
            headA = headA->next;
            cntA--;
        }
    }else{
        while(cntB>cntA){
            headB = headB->next;
            cntB--;
        }
    }

    while(headA && headB){
        if(headA == headB){
            return headA;
        }
        headA = headA->next;
        headB = headB->next;
    }
    return NULL;
}

Leecode-19-删除链表中的第N个结点

题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例

示例1

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

示例2

输入：head = [1], n = 1
输出：[]

示例3

输入：head = [1,2], n = 1
输出：[1]

解题思路、

1. 创建一个虚拟头结点dummyhead，便于删除节点，使虚拟头结点指向传入的头节点head
2. 定义两个临时指针变量，分别指向虚拟头结点dummyhead和head
3. 使快指针pCurrent向后移动n个节点
4. 同时移动快慢指针pPrev和pCurrent，当pCurrent为空，此时pPrev指向倒数第N个节点的上一个节点，移动pPrev
5. 返回头节点的下一个节点

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummyhead = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummyhead->next = head;
    struct ListNode* pPrev = dummyhead;
    struct ListNode* pCurrent = head;
    while(n--){
        pCurrent = pCurrent->next;
    }
    while(pCurrent){
        pPrev = pPrev->next;
        pCurrent = pCurrent->next;
    }
    pPrev->next = pPrev->next->next;
    return dummyhead->next;
}