# Linked List | 7 Days, 3 LeetCode Problems a Day

## 1) 206. Reverse Linked List | Easy

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:**

`var reverseList = function(head) {`

let prev = null;

let current = head;

while (current !== null) {

let next = current.next;

current.next = prev;

prev = current;

current = next;

}

return prev;

};

## 2) 21. Merge Two Sorted Lists | Easy

You are given the heads of two sorted linked lists `list1`

and `list2`

.

Merge the two lists into one **sorted** list. The list should be made by splicing together the nodes of the first two lists.

Return *the head of the merged linked list*.

**Example 1:**

`Input: list1 = [1,2,4], list2 = [1,3,4]`

Output: [1,1,2,3,4,4]

**Example 2:**

`Input: list1 = [], list2 = []`

Output: []

**Example 3:**

`Input: list1 = [], list2 = [0]`

Output: [0]

**Constraints:**

- The number of nodes in both lists is in the range
`[0, 50]`

. `-100 <= Node.val <= 100`

- Both
`list1`

and`list2`

are sorted in**non-decreasing**order.

**Solution:**

`var mergeTwoLists = function(l1, l2) {`

let dummy = new ListNode(0);

let current = dummy;

while (l1 !== null && l2 !== null) {

if (l1.val < l2.val) {

current.next = l1;

l1 = l1.next;

} else {

current.next = l2;

l2 = l2.next;

}

current = current.next;

}

current.next = l1 !== null ? l1 : l2;

return dummy.next;

};

## 3) 143. Reorder List | Medium

You are given the head of a singly linked-list. The list can be represented as:

`L0 → L1 → … → Ln - 1 → Ln`

*Reorder the list to be on the following form:*

`L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …`

You may not modify the values in the list’s nodes. Only nodes themselves may be changed.

**Example 1:**

`Input: head = [1,2,3,4]`

Output: [1,4,2,3]

**Example 2:**

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

Output: [1,5,2,4,3]

**Constraints:**

- The number of nodes in the list is in the range
`[1, 5 * 104]`

. `1 <= Node.val <= 1000`

**Solution:**

var reorderList = function(head) {

if (!head || !head.next) return;

// 1. Split the list

let slow = head, fast = head;

while (fast.next && fast.next.next) {

slow = slow.next;

fast = fast.next.next;

}

// 2. Reverse the second half

let prev = null, curr = slow.next;

slow.next = null;

while (curr) {

let nextTemp = curr.next;

curr.next = prev;

prev = curr;

curr = nextTemp;

}

// 3. Merge the two lists

let first = head, second = prev;

while (second) {

let nextTemp = first.next;

first.next = second;

first = first.next;

second = second.next;

first.next = nextTemp;

first = first.next;

}

};