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 incidate 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: List Operations

Find the following nodes:
1. previous node to the a-th node: prev_a
2. the b-th node: node_b
3. tail node of list2: tail2

prev_a->next = list2
tail2->next = node_b

return list1

Time complexity: O(m+n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
    ListNode dummy(0, list1);
    ListNode* prev_a = &dummy;
    for (int i = 0; i < a; ++i) prev_a = prev_a->next;
    ListNode* node_b = prev_a->next;
    for (int i = a; i <= b; ++i) node_b = node_b->next;
    ListNode* tail2 = list2;
    while (tail2->next) tail2 = tail2->next;
    
    prev_a->next = list2;    
    tail2->next = node_b;
    return list1;
  }
};

The post 花花酱 LeetCode 1669. Merge In Between Linked Lists appeared first on Huahua's Tech Road.

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

Solution 0: Cheating! store the nodes in an array

// Author: Huahua
class Solution {
public:
  ListNode *removeNthFromEnd(ListNode *head, int n) {
    if (!head) return nullptr;
    vector<ListNode *> nodes;
    ListNode *cur = head;
    while (cur) {
      nodes.push_back(cur);
      cur = cur->next;
    }
    if (n == nodes.size()) return head->next;
    ListNode* nodes_to_remove = nodes[nodes.size()-n];
    ListNode* parent = nodes[nodes.size() - n - 1];
    parent->next = nodes_to_remove->next;
    delete nodes_to_remove;
    return head;
  }
};

Solution 1: Two passes

Time complexity: O(L)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  ListNode* removeNthFromEnd(ListNode* head, int n) {
    int l = 0;
    ListNode* cur = head;
    while (cur) {
      ++l;
      cur = cur->next;
    }
    if (n == l) {
      ListNode* ans = head->next;
      delete head;
      return ans;
    }    
    l -= n;
    cur = head;
    while (--l) cur = cur->next;
    ListNode* node = cur->next;
    cur->next = node->next;
    delete node;
    return head;
  }
};

Solution 2: Fast/Slow Pointers + Dummy Head / Prev

Fast pointer moves n steps first, and then slow pointer starts moving.

When fast pointer reaches tail, slow pointer is n-th node from the end.

Time complexity: O(L)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* fast = head;
    for (int i = 0; i < n; ++i) 
      fast = fast->next;
    ListNode dummy(0);
    dummy.next = head;
    ListNode* prev = &dummy;
    while (fast) {
      fast = fast->next;
      prev = prev->next;
    }
    ListNode* node = prev->next;
    prev->next = node->next;
    delete node;
    return dummy.next;
  }
};

// Author: Huahua
class Solution {
  public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode fast = head;
    while (n-- > 0) fast = fast.next;
    ListNode prev = dummy;
    while (fast != null) {
      fast = fast.next;
      prev = prev.next;
    }
    prev.next = prev.next.next;
    return dummy.next;
  }
}

# Author: Huahua
class Solution:
  def removeNthFromEnd(self, head, n):
    dummy = ListNode(0)
    dummy.next = head
    fast, prev = head, dummy
    for _ in range(n): 
      fast = fast.next
    while fast:
      fast, prev = fast.next, prev.next
    prev.next = prev.next.next
    return dummy.next

The post 花花酱 LeetCode 19. Remove Nth Node From End of List appeared first on Huahua's Tech Road.

Solution

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 21 ms
class Solution {
public:
  ListNode* oddEvenList(ListNode* head) {
    if (head == nullptr) return head;
    ListNode dummy_odd(0);
    ListNode dummy_even(0);
    ListNode* prev_odd = &dummy_odd;
    ListNode* prev_even = &dummy_even;
    int index = 0;
    while (head) {      
      auto next = head->next;
      head->next = nullptr; // important
      if (index++ & 1) {
        prev_even->next = head;
        prev_even = head;
      } else {
        prev_odd->next = head;
        prev_odd = head;
      }
      head = next;
    }
    prev_odd->next = dummy_even.next;
    return dummy_odd.next;
  }
};

V2

// Author: Huahua
// Running time: 18 ms
class Solution {
public:
  ListNode* oddEvenList(ListNode* head) {
    if (head == nullptr) return head;
    vector<ListNode> heads(2, ListNode(0));    
    vector<ListNode*> prevs{&heads[0], &heads[1]};
    int index = 0;
    while (head) {
      auto next = head->next;
      head->next = nullptr; // important      
      prevs[index]->next = head;
      prevs[index] = head;
      head = next;
      index ^= 1;
    }
    prevs[0]->next = heads[1].next;
    return heads[0].next;
  }
};

Java

// Author: Huahua
// Running time: 1 ms
class Solution {
  public ListNode oddEvenList(ListNode head) {
    ListNode[] heads = new ListNode[]{new ListNode(0), new ListNode(0)};
    ListNode[] prevs = new ListNode[]{heads[0], heads[1]};
    int index = 0;
    while (head != null) {
      ListNode next = head.next;
      head.next = null;
      prevs[index].next = head;
      prevs[index] = prevs[index].next;
      head = next;
      index ^= 1;
    }
    prevs[0].next = heads[1].next;
    return heads[0].next;
  }
}

Python3

"""
Author: Huahua
Running time: 56 ms
"""
class Solution:
  def oddEvenList(self, head):
    heads = [ListNode(0), ListNode(0)]
    prevs = [heads[0], heads[1]]
    index = 0
    while head:
      nxt = head.next
      head.next = None
      prevs[index].next = head
      prevs[index] = prevs[index].next
      head = nxt
      index ^= 1
    prevs[0].next = heads[1].next
    return heads[0].next

The post 花花酱 LeetCode 328. Odd Even Linked List appeared first on Huahua's Tech Road.