Leetcode Reverse-Linked-List

2022-06-15 22:07

Algorithms:

#algorithm #recursion #iteration

Data structures:

#DS #linked_list

Difficulty:

#leetcode #coding_problem #difficulty-medium

Lists:

#CS_list_need_understanding #CS_list_need_practicing

tag:#linked_list

Problem

Given the head of a singly linked list, reverse the list, and return the reversed list.

Examples

Example 1:

**Input:** head = [1,2,3,4,5]
**Output:** [5,4,3,2,1]

Example 2:

**Input:** head = [1,2]
**Output:** [2,1]

Example 3:

**Input:** head = []
**Output:** []

Constraints

The number of nodes in the list is the range [0, 5000].
-5000 <= Node.val <= 5000

Thoughts

I thought a slow O(n ^ 2) hybrid solution, while there are better algorithms, using in-place insert, or recursion.

The in place insert is easier to understand, and simple to implement, using a very clever trick.

Solution

I've referred to this guy: https://leetcode.com/problems/reverse-linked-list/discuss/58130/C%2B%2B-Iterative-and-Recursive

This code is hard to understand. ==TODO==: Make my own version

class Solution {
public:
  ListNode *reverseList(ListNode *head) {
    ListNode *pre = new ListNode(0), *cur = head;
    // pre is before head, and insert any element after pre.
    pre->next = head;
    while (cur && cur->next) {
      // temp points to head
      ListNode *temp = pre->next;
      // Move cur->next after pre.
      pre->next = cur->next;
      // Fix pointers, because cur->next is unchanged when changing position.
      cur->next = cur->next->next;
      pre->next->next = temp;
    }
    return pre->next;
  }
};

Recursion:

class Solution {
public:
  ListNode *reverseList(ListNode *head) {
    // Base case: reached the end of list
    if (!head || !(head->next)) {
      return head;
    }

    // node is the end of linked list, which stays the same and untouched
    ListNode *node = reverseList(head->next);
    // change head->next
    head->next->next = head;
    head->next = NULL;
    return node;
  }
};

2.4 KiB Raw Blame History