# .css-df1pn7{display:block;width:16rem;}     # Reverse Linked List With JavaScript

Blake Yeboah
·Dec 4, 2021·

Subscribe to my newsletter and never miss my upcoming articles

In this article, I will be showing you how to solve the LeetCode Reverse Linked List problem using JavaScript. I'll explain each step of developing a solution to help you improve your problem solving skills.

Lets get right into it

## The Problem The question is asking us to reverse a linked list. Fairly simple right?

The structure of a list node from LeetCode is as follows:

``````/**
* Definition for singly-linked list.
* function ListNode(val, next) {
*     this.val = (val===undefined ? 0 : val)
*     this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} head
* @return {ListNode}
*/
``````

So the function takes in one parameter - head, and then returns a new List Node with the linked list reversed.

## The Solution

To start off, we will need two variables. One variable will be for storing the current list item we are on - lets call this `current`. The initial value will be the `head` since we will loop through the list starting with `head`.

The second variable will be used for storing the previous list node which will allow us to reverse the list - lets call this `prev`. The initial value for `prev` will be null since at the start there will be no previous node.

At this point, after declaring these variables our solution looks like this:

``````var reverseList = function(head) {
let current = head;
let prev = null;
};
``````

Using `let` to define these variables is important since we will need to reassign them later on.

Next, we will use a `while` loop with the condition set to `current` so that it stops when there is no `current` value, meaning we are at the end of the list.

Establish the `while` loop:

``````var reverseList = function(head) {
let current = head;
let prev = null;
while (current) {

}
};
``````

Within this loop, we are gonna reverse each node by setting the current node's `next` equal to `prev`, the previous node, and changing the `current` node to the original next value. This may sound confusing, the code makes it look more clear:

``````var reverseList = function(head) {
let current = head;
let prev = null;
while (current) {
let hold = current.next; // Hold original next value
current.next = prev; // Set the next value to the previous which reverses the list
prev = current; // Move previous value to current value (move through list)
current = hold; // Set current node to original next value
}
};
``````

We have now reversed the list so to complete our solution, we just have to return the `prev` value:

``````var reverseList = function(head) {
let current = head;
let prev = null;
while (current) {
let hold = current.next; // Hold original next value
current.next = prev; // Set the next value to the previous which reverses the list
prev = current; // Move previous value to current value (move through list)
current = hold; // Set current node to original next value
}
return prev
};
``````

The reason why we are return `prev` and not `current` is because when we reach the end of the list, the `current` node will be set to `null` since the `next` of the last node will equal `null`. We don't want to return null but rather the `head` of our new, reversed list. Hence, we return `prev`.

## Take Away

You've now learned how to reverse a linked list using the JavaScript programming language. Its a fairly simple solution that efficiently reverses the linked list.

If you like what I do and would love to see more related content, follow me on my other social platforms:

GitHub: Blake-K-Yeboah 