# yaox023's blog Given the head of a singly linked list, how to reverse with `O(1)` space complexity?

What we will do is, initialize two pointers, pointer `cur` poninted to the head and pointer `pre` pointed to null. Then iterate the while linked list. For every iteration, do the 3 steps:

1. make `cur` node points to `pre` node
2. move `pre` forward(points to `cur`)
3. move `cur` forward(points to `cur.next`)

Take `2->4->6->8->null` as an example.

``````2->4->6->8->null, pre:null, cur:2
null<-2->4->6->8->null, pre:2, cur:4
null<-2<-4->6->8->null, pre:4, cur:6
null<-2<-4<-6->8->null, pre:6, cur:8
null<-2<-4<-6<-8->null, pre:8, cur:null
``````

At the end, we can return the `pre` node, which will be the new head of the reversed linked list.

``````function reverseList(head: ListNode | null): ListNode | null {
let pre = null;
let next = null;

while (cur !== null) {
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}

return pre;
};
``````

Note above we need to `next` pointer to help the swap process. We can use the array deconstructing feature to make the process more concise.

``````function reverseList(head: ListNode | null): ListNode | null {
let pre = null;

while (cur !== null) {
[pre, cur.next, cur] = [cur, pre, cur.next];
}

return pre;
};
``````

Because this swapping process is the same for every node in the linked list, so we can do it in the recursive way.

``````function reverseRecursive(pre: ListNode | null, cur: ListNode | null): ListNode | null {
if (cur === null) {
return pre;
}

[pre, cur.next, cur] = [cur, pre, cur.next]
return reverseRecursive(pre, cur);
}

function reverseList(head: ListNode | null): ListNode | null {
};
``````

Now the problem becomes to reverse a sublist from the linked list. Problem signature becomes:

``````function reverseBetween(head: ListNode | null, left: number, right: number): ListNode | null
``````

As you can see, reverse whole linked list can be seen as one special case for this `reverseBetween` problem. We can still use the above swapping method to solve this problem. The hard part is that now the array can be split into 3 parts: part before left, part between left and right, part after right. So what we need to do is, reverse part between left and right first, and then somehow make these 3 parts connected properly.

``````function reverseBetween(head: ListNode | null, left: number, right: number): ListNode | null {
if (left === right) return head;

let pre = null;
let count = 1;

// find the left index node first
// if count equals left, then cur points to the left index node
while (cur !== null && count < left) {
pre = cur;
cur = cur.next;
count += 1;
}

// these two nodes can be used later to connect the linked list again
let lastNodeBeforeLeft = pre;
let lastNodeBetweenLeftAndRight = cur;

// reverser the part between left and right
// if count equals right, then its the last swapping operation
while (count <= right) {
[pre, cur.next, cur] = [cur, pre, cur.next];
count += 1;
}

// connect the part before left with the part between left and right
if (lastNodeBeforeLeft === null) {