【链表】相关类型题目整理[二]

一、力扣21.合并两个有序链表

• 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
• 输入输出示例：

• 提示：

（一）直接修改节点中的val[一般情况下不可取]

• 第一步，先将两个链表合并起来；
• 第二步，遍历一遍合并以后的链表，将他们的val值装入一个vector中；
• 第三步，对vector从小到大排序；
• 第四步，将排好序的vector中的元素按照顺序依次装入链表中；
• 第五步，返回这个合并好的链表。
• 但是在面试的时候需要问清楚面试官允许不允许直接修改节点的值，如果不允许我们就要考虑另外的方法了。
• 代码如下：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
{
    if (l1 == nullptr && l2 != nullptr) return l2;
    if (l2 == nullptr && l1 != nullptr) return l1;

    //先将两个链表合并起来
    ListNode* head1 = l1;
    while (head1->next != nullptr)
    {
        head1 = head1->next;
    }
    head1->next = l2;

    //定义一个vector,将链表中元素的值装入vector中，再对vector进行排序；
    vector<int> res;
    head1 = l1;
    while (head1 != nullptr)
    {
        res.push_back(head1->val);
        head1 = head1->next;
    }
    sort(res.begin(), res.end());

    //将排好序的val依次装入链表中
    head1 = l1;
    for (int i = 0; i < res.size(); i++)
    {
        head1->val = res[i];
        head1 = head1->next;
    }
    return l1;
}

（二）迭代法

• 思路：
• 我们先设置一个伪头节点，为的是连接第一个val最小的节点；
• 然后当两个链表都不为空的时候，我们依次比较两个链表中哪个节点的val值小，然后将它连接到伪头节点中；
• 接着将伪头节点设置成刚刚连接的这个新节点，继续比较两个链表中节点的val值；
• 直到有一个链表中的节点被全部比较完了；
• 将还没有为空的链表直接连接到伪头的next即可。
• 如下图所示：
• 整个过程如下图所示：

• 按照这个过程一直到某一个链表为空以后，就直接将不为空的链表连接到prev后面即可。

• 代码如下：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
{
    if (l1 == nullptr && l2 != nullptr) return l2;
    if (l2 == nullptr && l1 != nullptr) return l1;

    //先定义一个伪头
    ListNode* head = new ListNode(-1);
    ListNode* vir = head;

    //依次遍历两个链表的节点，哪个节点对应的val值较小就把哪个节点接在伪头后面，然后伪头变成了新接的节点
    while (l1 != nullptr && l2 != nullptr)
    {
        if (l1->val <= l2->val)
        {
            vir->next = l1;
            l1 = l1->next;
        }
        else
        {
            vir->next = l2;
            l2 = l2->next;
        }
        vir = vir->next;
    }
     // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
    vir->next = l1 == nullptr ? l2 : l1;
    return head->next;
}

（三）递归

• 代码如下：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
{
    if (l1 == nullptr) 
    {
        return l2;
    }
    else if (l2 == nullptr)
    {
        return l1;
    }
    else if (l1->val < l2->val) 
    {
        l1->next = mergeTwoLists(l1->next, l2);
        return l1;
    }
    else 
    {
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }
}

二、力扣23.合并k个升序链表

• 给你一个链表数组，每个链表都已经按升序排列。
• 请你将所有链表合并到一个升序链表中，返回合并后的链表。
• 输入输出示例：

• 提示：

（一）暴力解法

• 思路：由于那些高级的算法我一点都不知道，所以这道题我就想到用暴力解法解决，先用暴力解法解决再慢慢优化，具体思路如下：
• 首先我们可以将所有的链表中节点的val值放入一个vector中，然后对vector中的元素进行排序；
• 拍好序之后为了不让开辟新的节点内存，我们可以使用原来已经有的节点节省一点空间，将所有的链表合成一个长链表；
• 然后从长链表的头开始，将它们里面的val值依次赋值成vector中已经排好序的值；
• 最后再将这个长链表的头指针返回即可。
• 代码如下：

ListNode* mergeKLists(vector<ListNode*>& lists) 
{
    if (lists.size() == 0) return nullptr;
    vector<int> vec;
    for (int i = 0; i < lists.size(); i++)
    {
        ListNode* tmp = lists[i];
        while (tmp != nullptr)
        {
            vec.push_back(tmp->val);
            tmp = tmp->next;
        }
    }

    sort(vec.begin(), vec.end());

    ListNode* vir = new ListNode(-1);
    vir->next = lists[0];
    ListNode* cur = vir;
    for (int i = 1; i < lists.size(); i++)
    {
        while (cur->next != nullptr)
        {
            cur = cur->next;
        }
        cur->next = lists[i];
    }

    cur = vir;
    int i = 0;
    while (cur->next != nullptr)
    {
        cur = cur->next;
        if (i < vec.size())
        {
            cur->val = vec[i++];
        }
    }
    return vir->next;
}

• 时间复杂度 = 遍历每个链表的时间O(k*N) + 遍历长链表的时间O(M[M=kN]) + vector排序的时间O(nlogn)
• 空间是以一个vector为代价的。

（二）两两合并

• 思路也比较容易想：
• 先将前两个链表合并成一个链表；
• 然后再将合并后的链表与第三个链表合并；
• 依次直到合并完所有链表；
• 最后将头返回即可。
• 代码如下：

ListNode* mergeTwoList(ListNode* list1, ListNode* list2)
{
    if (list1 == nullptr)
    {
        return list2;
    }
    if (list2 == nullptr)
    {
        return list1;
    }

    ListNode* p1 = list1;
    ListNode* p2 = list2;

    ListNode* vir = new ListNode(-1);
    vir->next = nullptr;
    ListNode* phead = vir;

    while (p1 != nullptr && p2 != nullptr)
    {
        if (p1->val <= p2->val)
        {
            phead->next = p1;
            p1 = p1->next;
        }
        else
        {
            phead->next = p2;
            p2 = p2->next;
        }
        phead = phead->next;
    }
    phead->next = p1 ? p1 : p2;
    return vir->next;
}

ListNode* mergeKLists(vector<ListNode*>& lists)
{
    ListNode* head = nullptr;
    for (int i = 0; i < lists.size(); i++)
    {
        head = mergeTwoList(head, lists[i]);
    }
    return head;
}

（三）分治合并

• 思路：
• 将k个链表合并并将同一对中的链表合并
• 第一轮合并后链表被合并成了k/2个链表；
• 然后k/4，k/8等等；
• 重复该过程直到得到最终的有序链表；
• 如下图所示：

• 代码如下：

ListNode* mergeTwoList(ListNode* list1, ListNode* list2)
{
    if (list1 == nullptr)
    {
        return list2;
    }
    if (list2 == nullptr)
    {
        return list1;
    }

    ListNode* p1 = list1;
    ListNode* p2 = list2;

    ListNode* vir = new ListNode(-1);
    vir->next = nullptr;
    ListNode* phead = vir;

    while (p1 != nullptr && p2 != nullptr)
    {
        if (p1->val <= p2->val)
        {
            phead->next = p1;
            p1 = p1->next;
        }
        else
        {
            phead->next = p2;
            p2 = p2->next;
        }
        phead = phead->next;
    }
    phead->next = p1 ? p1 : p2;
    return vir->next;
}

ListNode* merge(vector<ListNode*>& lists, int start, int right)
{
    if (start == right) return lists[start];
    if (start > right)return nullptr;
    int mid = (start + right) >> 1;
    return mergeTwoList(merge(lists, start, mid), merge(lists, mid + 1, right));
}

ListNode* mergeKLists(vector<ListNode*>& lists)
{
    return merge(lists, 0, lists.size() - 1);
}

（四）优先队列合并【后期更新】

三、力扣1669.合并两个链表

• 给你两个链表 list1 和 list2 ，它们包含的元素分别为 n 个和 m 个。
• 请你将 list1 中第 a 个节点到第 b 个节点删除，并将list2 接在被删除节点的位置。
• 请你返回结果链表的头指针。
• 下图中蓝色边和节点展示了操作后的结果：

• 输入输出示例1：

• 输入输出示例2：

（一）中规中矩+时间复杂度O(N)

• 思路：题目中的输入输出示例很明确了，根据示例的提示直接码代码就行
• 首先在list1中找到要移除的区域（也有可能a==b只移除一个节点），以及要a位置对应节点的前一个节点和b位置对应节点的后一个节点；
• 找到之后将要移除的节点与list节点断开；
• 然后找到list2中的最后一个节点；
• 再将list2的头节点接到a位置的前一个节点后面，将list2的尾节点的next指向b位置的后一个节点；
• 返回list1，题目完成。
• 代码如下：

ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) 
{
    //为了解决a和b为头节点的特殊情况，设置一个伪头节点
    ListNode* vir = new ListNode(-1);
    vir->next = list1;
    ListNode* cur = vir;

    //找到a位置对应节点的前一个节点
    ListNode* leftpre = vir;
    for (int i = 0; i < a; i++)
    {
        leftpre = leftpre->next;
    }

    //找到a位置对应的节点
    ListNode* leftNode = leftpre->next;

    //找到b位置对应的节点以及它的下一个节点
    ListNode* rightNode = leftNode;
    for (int i = 0; i < b - a; i++)
    {
        rightNode = rightNode->next;
    }
    ListNode* rightnext = rightNode->next;

    //将要移除的节点区间断开
    leftpre->next = nullptr;
    rightNode->next = nullptr;

    //找到list2的尾节点
    ListNode* tail = new ListNode(-1);
    tail->next = list2;
    while (tail->next != nullptr)
    {
        tail = tail->next;
    }

    //将list2接入到list1中
    leftpre->next = list2;
    tail->next = rightnext;

    //返回list1
    return vir->next;
}

四、力扣237.删除链表中的节点

• 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
• 现有一个链表 – head = [4,5,1,9]，它可以表示为:

• 输入输出以及提示：

（一）与下一个节点进行交换

• 思路：根据题目要求，我们只能知道要删除的节点以及它以后的节点，而无法知道要删除节点之前的节点，因此用要删除节点之前节点的next指向要删除节点的后一个节点，这种方法是实现不了了。
• 因此我们可以考虑删除要删除节点的后一个节点
• 将后一个节点的val值赋给要删除节点，然后再删除要删除节点的后一个节点。
• 比如有这样一个链表，要删除3这个节点

• 与4这个节点进行交换以后再将4节点删除

• 由于题目明确说明了我们要删除的节点不是尾节点，因此这种方法是可行的。
• 代码如下：

void deleteNode(ListNode* node)
{
    node->val = node->next->val;
    node->next = node->next->next;
}

五、力扣203.移除链表元素

• 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 .
• 输入输出示例：

• 提示：

（一）伪头节点+指针

• 思路如下图所示：

• 代码如下：

ListNode* removeElements(ListNode* head, int val)
{
    if (head == nullptr)
    {
        return head;
    }
    
    //定义一个伪头节点
    ListNode* vir = new ListNode(-1);
    vir->next = head;

    //指向当前节点的前一个节点
    ListNode* pre = vir;

    //当前节点；
    ListNode* cur = head;

    //当前节点的下一个节点
    ListNode* next = nullptr;

    while (cur != nullptr)
    {
        next = cur->next;
        if (cur->val == val)
        {
            pre->next = next;
            cur = next;
        }
        else
        {
            pre = cur;
            cur = next;
        }
    }
    return vir->next;
}

六、面试题02.01.移除重复节点

• 编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。
• 输入输出示例：

（一）一次遍历+哈希表

• 思路：
• 首先这道题的本质问题还是删除节点；
• 就是在删除节点的问题上要求节点的val值不重复；
• 我们很容易能想到用哈希表判断当前节点的val值在链表的之前节点中有没有出现；
• 因此我们可以一边遍历链表，一边将遍历过的节点的val值存入哈希表中；
• 然后在遍历下一个节点的时候判断该节点的val值有没有在哈希表中出现过；
• 如果出现了就将该节点删除；
• 如果没有出现，就让哨兵指针继续跑；
• 直到当前哨兵跑到nullptr为止。
• 如下图所示：

• 代码如下：

ListNode* removeDuplicateNodes(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }

    //创建哈希表
    unordered_map<int, int> hash;

    //构建一个伪头节点
    ListNode* vir = new ListNode(-1);
    vir->next = head;
    
    //设置哨兵节点
    ListNode* pre = vir;
    ListNode* cur = head;
    ListNode* next = nullptr;

    //开始遍历链表，边遍历边删除重复节点
    while (cur != nullptr)
    {
        next = cur->next;
        if (hash.find(cur->val) != hash.end())
        {
            pre->next = next;
        }
        else
        {
            pre = cur;
        }
        hash[cur->val]++;
        cur = next;
    }
    return vir->next;
}

（二）空间复杂度为O(1)的解法

• 思路：在保证时间复杂度为O(n)的情况下是不存在能够在O(1)的空间下解决这道题目的；
• 因此在不浪费空间的情况下我们可以选择用双重循环来解决这道题目；
• 思想也比较简单，就是看当前节点的val值和之后的所有节点的val值是不是相等，若相等，则将当前节点之后的那个相同节点移除掉；
• 如下图所示：

• 代码如下：

ListNode* removeDuplicateNodes(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }

    ListNode* cur = head;
    ListNode* next = nullptr;

    while (cur != nullptr)
    {
        next = cur->next;
        ListNode* tmp = cur;
        while (next != nullptr)
        {
            if (cur->val == next->val)
            {
                tmp->next = next->next;
                next = next->next;
            }
            else
            {
                tmp = next;
                next = next->next;
            }
        }
        cur = cur->next;
    }
    return head;
}

七、力扣83.删除排序链表中的重复元素

• 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
• 返回同样按升序排列的结果链表。
• 输入输出示例1：

• 输入输出示例2：

• 提示：

（一）时间复杂度O(n)+空间复杂度O(1)

• 这道题和第六题《移除重复节点》来比的话，唯一不同的一点就是本道题中给的链表都是排序好的链表，因此我们在解决这道题目的时候可以不用哈希表就能实现时间复杂度为O(1)的算法。
• 思路如下所示：

• 代码如下：

ListNode* deleteDuplicates(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }
    ListNode* cur = head;
    ListNode* next = cur->next;
    while (next != nullptr)
    {
        if (cur->val == next->val)
        {
            cur->next = next->next;
            next = next->next;
        }
        else
        {
            cur = next;
            next = next->next;
        }
    }
    return head;
}

八、力扣82.删除排序链表中的排序元素II.

• 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
• 返回同样按升序排列的结果链表。
• 输入输出示例1：

• 输入输出示例2：

• 提示：

（一）两次遍历+哈希表

• 思路：
• 首先定义一个哈希表，遍历一次链表，将链表中的节点对应的val值作为key，其出现的次数作为value值，放入哈希表中；
• 进行第二次遍历链表，若当前节点的val值在哈希表中只出现了一次，则将它连接到新的伪头节点的下一个节点；
• 否则，继续遍历原链表中的下一个节点。
• 如下图所示：

• 代码如下：

ListNode* deleteDuplicates(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }
    unordered_map<int, int> hash;
    ListNode* cur = head;
    while (cur != nullptr)
    {
        hash[cur->val]++;
        cur = cur->next;
    }
    
    cur = head;
    ListNode* vir = new ListNode(-1);
    vir->next = nullptr;
    ListNode* phead = vir;

    while (cur != nullptr)
    {
        if (hash[cur->val] == 1)
        {
            phead->next = cur;
            phead = phead->next;
        }
        cur = cur->next;
    }
    phead->next = nullptr;
    return vir->next;
}

（二）一次遍历+空间复杂度O(1)

• 思路
• 由于给定的链表是排好序的，因此重复的元素在链表中出现的位置是连续的，因此我们只需要对链表进行一次遍历，就可以删除重复的元素。
• 由于链表的头节点可能会被删除，因此我们需要额外使用一个哑节点指向链表的头节点。
• 具体地，我们让指针 cur 指向链表的哑节点，随后开始对链表进行遍历。
• 如果当前 cur->next 与cur->next->next 对应的元素相同，那么我们就需要将 cur->next 以及所有后面拥有相同元素值的链表节点全部删除。
• 我们记下这个元素值 x，随后不断将 cur->next 从链表中移除，直到 cur->next为空节点或者其元素值不等于 x 为止。
• 此时，我们将链表中所有元素值为 xx 的节点全部删除。
• 如果当前 cur->next与cur->next->next 对应的元素不相同，那么说明链表中只有一个元素值为cur->next的节点，那么我们就可以将 cur 指向 cur->next。
• 当遍历完整个链表之后，我们返回链表的的哑节点的下一个节点 即可。
• 代码如下：

ListNode* deleteDuplicates(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }

    //定义一个伪头节点
    ListNode* vir = new ListNode(-1);
    vir->next = head;
    ListNode* cur = vir;
 
    //开始遍历删除所有重复节点
    while (cur->next != nullptr && cur->next->next != nullptr)
    {
        if (cur->next->val == cur->next->next->val)
        {
            int x = cur->next->val;
            while (cur->next != nullptr && cur->next->val == x)
            {
                cur -> next = cur->next->next;
            }
        }
        else
        {
            cur = cur->next;
        }
    }
    return vir->next;
}

旺财加油！✨