目录

剑指 Offer 18. 删除链表的节点

剑指 Offer 22. 链表中倒数第k个节点

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

剑指 Offer 52. 两个链表的第一个公共节点

---

剑指 Offer 18. 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

【解法一】这个是没有重复的

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* newhead = new ListNode(0);
        newhead->next = head;
        ListNode* cur = head;
        ListNode* prev = newhead;
        // 新建一个头结点，这样删除的时候就不需要进行处理头为空的情况
        while(cur!=nullptr)
        {
            if(val == cur->val) // 如果cur为val利用前驱结点prev进行删除即可
            {
                prev->next = cur->next;
                cur = prev->next;
            }
            else
            {
                cur = cur->next; //如果不是那就俩个指针一起移动
                prev = prev->next;
            }
        }
        return newhead->next;
    }
};

【解法二】如果元素可以重复的话

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* newhead = new ListNode(0);
        newhead->next = head;
        ListNode* cur = head;
        ListNode* prev = newhead;
        // 新建一个头结点，这样删除的时候就不需要进行处理头为空的情况
        while(cur!=nullptr)
        {
            if(val == cur->val) // 如果cur为val利用前驱结点prev进行删除即可
            {
                while(cur->next && cur->next->val==val)
                {
                    cur = cur->next; // 在这里多一个循环，可以一次删除多个值
                }
                prev->next = cur->next;
                cur = prev->next;
            }
            else
            {
                cur = cur->next; //如果不是那就俩个指针一起移动
                prev = prev->next;
            }
        }
        return newhead->next;
    }
};

剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

【解法一】计数返回第n-k+1步

【解法二】双指针

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* slow = head;
        ListNode* fast = head;
        while(k--)
        {
            fast = fast->next;
        }
        while(fast)
        {
            slow = slow->next;
            fast = fast->next;
        }
        return slow;
    }
};

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

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

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

【解法一】双指针迭代

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // if(l1==nullptr)return l2;
        // if(l2==nullptr)return l1;
        ListNode* newhead = new ListNode(0);
        ListNode* cur = newhead;
        while(l1 && l2)
        {
            if(l1->val<=l2->val)
            {
                cur->next = l1;
                l1 = l1->next;
            }
            else
            {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = l1==nullptr?l2:l1;//三目运算符优化
        // if(l1==nullptr)
        //     cur->next = l2;
        // else
        //     cur->next = l1;
        return newhead->next;
    }
};

【解法二】递归

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        if(l1->val<=l2->val)
        {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

剑指 Offer 52. 两个链表的第一个公共节点

【解法一】双指针

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==nullptr || headB==nullptr)
            return nullptr;
        ListNode *l1 = headA, *l2 = headB;
        while(l1 != l2)
        {
            l1 = l1==nullptr ? headB : l1->next;
            l2 = l2==nullptr ? headA : l2->next;
        }
        return l1;
    }
};

【解法二】哈希

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};


作者：LeetCode-Solution
链接：https://leetcode.cn/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/liang-ge-lian-biao-de-di-yi-ge-gong-gong-pzbs/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。