node Archives - Huahua's Tech Road

花花酱 LeetCode 61. Rotate List

zxi — Thu, 29 Oct 2020 05:59:44 +0000

Given a linked list, rotate the list to the right by k places, where k is non-negative.

Example 1:

Input: 1->2->3->4->5->NULL, k = 2
Output: 4->5->1->2->3->NULL
Explanation:
rotate 1 steps to the right: 5->1->2->3->4->NULL
rotate 2 steps to the right: 4->5->1->2->3->NULL

Example 2:

Input: 0->1->2->NULL, k = 4
Output: 2->0->1->NULL
Explanation:
rotate 1 steps to the right: 2->0->1->NULL
rotate 2 steps to the right: 1->2->0->NULL
rotate 3 steps to the right: 0->1->2->NULL
rotate 4 steps to the right: 2->0->1->NULL

Solution: Find the prev of the new head

Step 1: Get the tail node T while counting the length of the list.
Step 2: k %= l, k can be greater than l, rotate k % l times has the same effect.
Step 3: Find the previous node P of the new head N by moving (l – k – 1) steps from head
Step 4: set P.next to null, T.next to head and return N

Time complexity: O(n) n is the length of the list
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  ListNode* rotateRight(ListNode* head, int k) {
    if (!head) return head;    
    int l = 1;
    ListNode* tail = head;
    while (tail->next) { tail = tail->next; ++l; }
    k %= l;
    if (k == 0) return head;
    
    ListNode* prev = head;
    while (--l > k) prev = prev->next;
    ListNode* new_head = prev->next;
    tail->next = head;
    prev->next = nullptr;
    return new_head;
  }
};

Java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
  public ListNode rotateRight(ListNode head, int k) {
    if (head == null) return null;
    int l = 1;
    ListNode tail = head;
    while (tail.next != null) {
      tail = tail.next;
      ++l;
    }
    k %= l;
    if (k == 0) return head;
    
    ListNode prev = head;
    for (int i = 0; i < l - k - 1; ++i) {
      prev = prev.next;
    }
    
    ListNode new_head = prev.next;
    prev.next = null;
    tail.next = head;
    return new_head;
  }
}

Python3

class Solution:
  def rotateRight(self, head: ListNode, k: int) -> ListNode:
    if not head: return head
    tail = head
    l = 1
    while tail.next: 
      tail = tail.next
      l += 1
    k = k % l
    if k == 0: return head
    
    prev = head
    for _ in range(l - k - 1): prev = prev.next
    
    new_head = prev.next
    tail.next = head
    prev.next = None
    return new_head

The post 花花酱 LeetCode 61. Rotate List appeared first on Huahua's Tech Road.

花花酱 LeetCode 24. Swap Nodes in Pairs

zxi — Tue, 02 Oct 2018 15:59:12 +0000

Problem

Given a linked list, swap every two adjacent nodes and return its head.

Example:

Given 1->2->3->4, you should return the list as 2->1->4->3.

Note:

Your algorithm should use only constant extra space.
You may not modify the values in the list’s nodes, only nodes itself may be changed.

Solution

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  ListNode *swapPairs(ListNode *head) {
    if (!head || !head->next) return head;    

    ListNode d(0);
    d.next = head;
    head = &d;

    while (head && head->next && head->next->next) {
      auto n1 = head->next;
      auto n2 = n1->next;

      n1->next = n2->next;
      n2->next = n1;

      head->next = n2;
      head = n1;
    }
    return d.next;
  }
};

Python3

class Solution:
  def swapPairs(self, head):
    if not head or not head.next: return head
    dummy = ListNode(0)
    dummy.next = head
    head = dummy
    while head.next and head.next.next:
      n1, n2 = head.next, head.next.next
      n1.next = n2.next
      n2.next = n1
      head.next = n2      
      head = n1
    return dummy.next

花花酱 LeetCode 19. Remove Nth Node From End of List

zxi — Thu, 20 Sep 2018 06:54:23 +0000

Problem

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

C++

// Author: Huahua
class Solution {
public:
  ListNode *removeNthFromEnd(ListNode *head, int n) {
    if (!head) return nullptr;
    vector 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)

C++

// 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)

C++

// 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;
  }
};

Java

// 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;
  }
}

Python3

# 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.

node Archives - Huahua's Tech Road

花花酱 LeetCode 61. Rotate List

Solution: Find the prev of the new head

C++

Java

Python3

花花酱 LeetCode 24. Swap Nodes in Pairs

Problem

Solution

C++

Python3

Related Problems

花花酱 LeetCode 19. Remove Nth Node From End of List

Problem

Solution 0: Cheating! store the nodes in an array

C++

Solution 1: Two passes

C++

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

C++

Java

Python3