Skip to content

1669. Merge In Between Linked Lists

Difficulty Topics

Description

You are given two linked lists: list1 and list2 of sizes n and m respectively.

Remove list1's nodes from the ath node to the bth node, and put list2 in their place.

The blue edges and nodes in the following figure indicate the result:

Build the result list and return its head.

 

Example 1:

Input: list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
Output: [0,1,2,1000000,1000001,1000002,5]
Explanation: We remove the nodes 3 and 4 and put the entire list2 in their place. The blue edges and nodes in the above figure indicate the result.

Example 2:

Input: list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
Output: [0,1,1000000,1000001,1000002,1000003,1000004,6]
Explanation: The blue edges and nodes in the above figure indicate the result.

 

Constraints:

  • 3 <= list1.length <= 104
  • 1 <= a <= b < list1.length - 1
  • 1 <= list2.length <= 104

Solution

merge-in-between-linked-lists.py
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeInBetween(self, list1: ListNode, a: int, b: int, list2: ListNode) -> ListNode:


        res = head = curr = ListNode()
        curr.next = list1

        l = -1

        while curr:
            if l == a:
                head = curr.next

            if l == b:
                c = list2
                while c.next:
                    c = c.next
                curr = curr.next
                while curr:
                    c.next = curr
                    curr = curr.next
                    c = c.next

                break

            curr = curr.next
            l += 1

        l = -1
        temp = res
        while temp and l+1 != a:
            temp = temp.next
            l += 1

        temp.next = list2

        return res.next
merge-in-between-linked-lists.cpp
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
        ListNode *curr = new ListNode;
        curr->next = list1;
        ListNode *res = curr;

        for (int i = 0; i < a; i++)
            curr = curr->next;
        ListNode *prev = curr;

        for (int i = 0; i < b-a+1; i++)
            curr = curr->next;

        ListNode *temp = list2;
        while (temp->next)
            temp = temp->next;
        temp->next = curr->next;

        prev->next = list2;


        return res->next;
    }
};