# Reorder List LeetCode Solution | Easy Approach Share:

Reorder List 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`

Time: O(n)
Space: O(1)

### C++

`````` class Solution {
public:
return;

ListNode* reversed = reverse(mid);
}

private:
ListNode* prev = nullptr;

while (fast && fast->next) {
prev = slow;
slow = slow->next;
fast = fast->next->next;
}
prev->next = nullptr;

return slow;
}

ListNode* prev = nullptr;

while (curr) {
ListNode* next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}

return prev;
}

void merge(ListNode* l1, ListNode* l2) {
while (l2) {
ListNode* next = l1->next;
l1->next = l2;
l1 = l2;
l2 = next;
}
}
};``````

### Java

`````` class Solution {
return;

ListNode reversed = reverse(mid);
}

ListNode prev = null;

while (fast != null && fast.next != null) {
prev = slow;
slow = slow.next;
fast = fast.next.next;
}
prev.next = null;

return slow;
}

ListNode prev = null;

while (curr != null) {
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}

return prev;
}

private void merge(ListNode l1, ListNode l2) {
while (l2 != null) {
ListNode next = l1.next;
l1.next = l2;
l1 = l2;
l2 = next;
}
}
}
``````

### Python

``````class Solution:
def reorderList(self, head: ListNode) -> None:
prev = None

while fast and fast.next:
prev = slow
slow = slow.next
fast = fast.next.next
prev.next = None

return slow

prev = None

while curr:
next = curr.next
curr.next = prev
prev = curr
curr = next

return prev

def merge(l1: ListNode, l2: ListNode) -> None:
while l2:
next = l1.next
l1.next = l2
l1 = l2
l2 = next