Today I have done Reverse Linked List and leetcode's April LeetCoding Challenge with cpp.

Reverse Linked List

Description

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

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

Follow up: A linked list can be reversed either iteratively or recursively. Could you implement both?

Solution

reverse iteratively

class Solution {
public:
  ListNode* reverseList(ListNode* head) {
    ListNode *newHead = nullptr;
    ListNode *prev;
    ListNode *cur = head;
    while(cur) {
      prev = cur;
      cur = cur->next;
      prev->next = newHead;
      newHead = prev;
    }
    return newHead;
  }
};

reverse recursively

class Solution {
public:
  ListNode* reverseList(ListNode* head, ListNode* tail = nullptr) {
    if(!head) return tail;
    ListNode *next = head->next;
    head->next = tail;
    return reverseList(next, head);
  }
};

April LeetCoding challenge 14

Description

Partition List

Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example 1:

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

Example 2:

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

Constraints:

• The number of nodes in the list is in the range [0, 200].
• -100 <= Node.val <= 100
• -200 <= x <= 200

Solution

class Solution {
public:
  ListNode* partition(ListNode* head, int x) {
    ListNode *newFront = new ListNode(-1);
    ListNode *frontTail = newFront;
    ListNode *newBack = new ListNode(-1);
    ListNode *backTail = newBack;
    while(head) {
      if(head->val < x) {
        frontTail->next = head;
        frontTail = frontTail->next;
      } else {
        backTail->next = head;
        backTail = backTail->next;
      }
      head = head->next;
    } 
    backTail->next = nullptr;
    frontTail->next = newBack->next;
    ListNode* answer = newFront->next;
    delete newFront;
    delete newBack;
    return answer;
  }
};