Data Structures - Linked List Other Related Topics
Data Structures - Linked List Other Related Topics

Linked List - Reverse the List

While working with a Linked List, sometimes it is required to reverse it. Reversing a List produces following result: if the given List is 10->20->30->40->50, after reversing the List the List becomes 50->40->30->20->10.

Reversing a List requires creating three nodes, considering that the list is not empty, which are as follows: tempNode pointing to head, prevNode pointing to head and curNode pointing to next of head. Then make next of prevNode as null to make the first node as last node of the reversed list. After that, while the curNode is not null adjust links (unlink curNode and link it to the reversed list from front and modify curNode and prevNode to the next element in the list). At last, make the prevNode (last node) as head.

The function reverseList is created for this purpose. It is a 4-step process.

void reverseList() {
  //1. If head is not null create three nodes
  //   prevNode - pointing to head,
  //   tempNode - pointing to head,
  //   curNode - pointing to next of head
  if(head != NULL) {
    Node* prevNode = head;
    Node* tempNode = head;
    Node* curNode = head->next;
    
    //2. assign next of prevNode as null to make the
    //   first node as last node of the reversed list
    prevNode->next = NULL;
    
    while(curNode != NULL) {
      //3. While the curNode is not null adjust links 
      //   (unlink curNode and link it to the reversed list 
      //   from front and modify curNode and prevNode) 
      tempNode = curNode->next;
      curNode->next = prevNode;
      prevNode = curNode;
      curNode = tempNode;
    }

    //4. Make prevNode (last node) as head
    head = prevNode;
  }
} 

void reverseList(struct Node** head_ref) {
  //1. If head is not null create three nodes
  //   prevNode - pointing to head,
  //   tempNode - pointing to head,
  //   curNode - pointing to next of head
  if(*head_ref != NULL) {
    struct Node* prevNode = *head_ref;
    struct Node* tempNode = *head_ref;
    struct Node* curNode = (*head_ref)->next;
    
    //2. assign next of prevNode as null to make the
    //   first node as last node of the reversed list
    prevNode->next = NULL;
    
    while(curNode != NULL) {
      //3. While the curNode is not null adjust links 
      //   (unlink curNode and link it to the reversed list 
      //   from front and modify curNode and prevNode)  
      tempNode = curNode->next;
      curNode->next = prevNode;
      prevNode = curNode;
      curNode = tempNode;
    }

    //4. Make prevNode (last node) as head
    *head_ref = prevNode;
  }
} 

def reverseList(self):
  #1. If head is not null create three nodes
  #   prevNode - pointing to head,
  #   tempNode - pointing to head,
  #   curNode - pointing to next of head
  if(self.head != None):
    prevNode = self.head
    tempNode = self.head
    curNode = self.head.next
    
    #2. assign next of prevNode as null to make the
    #   first node as last node of the reversed list
    prevNode.next = None
    
    while(curNode != None):
      #3. While the curNode is not null adjust links 
      #   (unlink curNode and link it to the reversed list 
      #   from front and modify curNode and prevNode) 
      tempNode = curNode.next
      curNode.next = prevNode
      prevNode = curNode
      curNode = tempNode

    #4. Make prevNode (last node) as head
    self.head = prevNode 

void reverseList() {
  //1. If head is not null create three nodes
  //   prevNode - pointing to head,
  //   tempNode - pointing to head,
  //   curNode - pointing to next of head
  if(this.head != null) {
    Node prevNode = this.head;
    Node tempNode = this.head;
    Node curNode = this.head.next;
    
    //2. assign next of prevNode as null to make the
    //   first node as last node of the reversed list
    prevNode.next = null;
    
    while(curNode != null) {
      //3. While the curNode is not null adjust links 
      //   (unlink curNode and link it to the reversed list 
      //   from front and modify curNode and prevNode) 
      tempNode = curNode.next;
      curNode.next = prevNode;
      prevNode = curNode;
      curNode = tempNode;
    }

    //4. Make prevNode (last node) as head
    this.head = prevNode;
  }
}    

public void reverseList() {
  //1. If head is not null create three nodes
  //   prevNode - pointing to head,
  //   tempNode - pointing to head,
  //   curNode - pointing to next of head
  if(this.head != null) {
    Node prevNode = this.head;
    Node tempNode = this.head;
    Node curNode = this.head.next;
    
    //2. assign next of prevNode as null to make the
    //   first node as last node of the reversed list
    prevNode.next = null;
    
    while(curNode != null) {
      //3. While the curNode is not null adjust links 
      //   (unlink curNode and link it to the reversed list 
      //   from front and modify curNode and prevNode) 
      tempNode = curNode.next;
      curNode.next = prevNode;
      prevNode = curNode;
      curNode = tempNode;
    }

    //4. Make prevNode (last node) as head
    this.head = prevNode;
  }
}  

public function reverseList() {
  //1. If head is not null create three nodes
  //   prevNode - pointing to head,
  //   tempNode - pointing to head,
  //   curNode - pointing to next of head
  if($this->head != null) {
    $prevNode = $this->head;
    $tempNode = $this->head;
    $curNode = $this->head->next;
    
    //2. assign next of prevNode as null to make the
    //   first node as last node of the reversed list
    $prevNode->next = null;
    
    while($curNode != null) {
      //3. While the curNode is not null adjust links 
      //   (unlink curNode and link it to the reversed list 
      //   from front and modify curNode and prevNode)  
      $tempNode = $curNode->next;
      $curNode->next = $prevNode;
      $prevNode = $curNode;
      $curNode = $tempNode;
    }

    //4. Make prevNode (last node) as head
    $this->head = $prevNode;
  }
}

The below is a complete program that uses above discussed concept to reverse a given linked list.

#include <iostream>
using namespace std;

//node structure
struct Node {
    int data;
    Node* next;
};

class LinkedList {
  private:
    Node* head;
  public:
    LinkedList(){
      head = NULL;
    }
 
    //Add new element at the end of the list
    void push_back(int newElement) {
      Node* newNode = new Node();
      newNode->data = newElement;
      newNode->next = NULL; 
      if(head == NULL) {
        head = newNode;
      } else {
        Node* temp = head;
        while(temp->next != NULL)
          temp = temp->next;
        temp->next = newNode;
      }    
    }
    
    //reverse the list
    void reverseList() {
      if(head != NULL) {
        Node* prevNode = head;
        Node* tempNode = head;
        Node* curNode = head->next;
        
        prevNode->next = NULL;
        
        while(curNode != NULL) {
          tempNode = curNode->next;
          curNode->next = prevNode;
          prevNode = curNode;
          curNode = tempNode;
        }

        head = prevNode;
      }
    } 

    //display the content of the list
    void PrintList() {
      Node* temp = head;
      if(temp != NULL) {
        cout<<"The list contains: ";
        while(temp != NULL) {
          cout<<temp->data<<" ";
          temp = temp->next;
        }
        cout<<"\n";
      } else {
        cout<<"The list is empty.\n";
      }
    }   
};

// test the code 
int main() {
  LinkedList MyList;

  //Add five elements in the list.
  MyList.push_back(10);
  MyList.push_back(20);
  MyList.push_back(30);
  MyList.push_back(40);
  MyList.push_back(50);

  //Display the content of the list.
  MyList.PrintList();
  
  //Reversing the list.
  MyList.reverseList();
  
  //Display the content of the list.
  MyList.PrintList();
  
  return 0; 
}

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10 

#include <stdio.h>
#include <stdlib.h>

//node structure
struct Node {
  int data;
  struct Node* next;
};

//Add new element at the end of the list
void push_back(struct Node** head_ref, int newElement) {  
  struct Node *newNode, *temp;
  newNode = (struct Node*)malloc(sizeof(struct Node)); 
  newNode->data = newElement;  
  newNode->next = NULL;
  if(*head_ref == NULL) {
    *head_ref = newNode; 
  } else {
    temp = *head_ref;
    while(temp->next != NULL) {
      temp = temp->next;
    }    
    temp->next = newNode;
  }
}

//reverse the list
void reverseList(struct Node** head_ref) {
  if(*head_ref != NULL) {
    struct Node* prevNode = *head_ref;
    struct Node* tempNode = *head_ref;
    struct Node* curNode = (*head_ref)->next;
    
    prevNode->next = NULL;
    
    while(curNode != NULL) {
      tempNode = curNode->next;
      curNode->next = prevNode;
      prevNode = curNode;
      curNode = tempNode;
    }

    *head_ref = prevNode;
  }
} 

//display the content of the list
void PrintList(struct Node* head_ref) {
  struct Node* temp = head_ref;
  if(head_ref != NULL) {
    printf("The list contains: ");
    while (temp != NULL) {
      printf("%i ",temp->data);
      temp = temp->next;  
    }
    printf("\n");
  } else {
    printf("The list is empty.\n");
  }   
}

// test the code 
int main() {
  struct Node* MyList = NULL;

  //Add five elements in the list.
  push_back(&MyList, 10);
  push_back(&MyList, 20);
  push_back(&MyList, 30);
  push_back(&MyList, 40);
  push_back(&MyList, 50);

  //Display the content of the list.
  PrintList(MyList);

  //Reversing the list.
  reverseList(&MyList);
  
  //Display the content of the list.
  PrintList(MyList);

  return 0; 
}

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10 

# node structure
class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

#class Linked List
class LinkedList:
  def __init__(self):
    self.head = None

  #Add new element at the end of the list
  def push_back(self, newElement):
    newNode = Node(newElement)
    if(self.head == None):
      self.head = newNode
      return
    else:
      temp = self.head
      while(temp.next != None):
        temp = temp.next
      temp.next = newNode

  #reverse the list
  def reverseList(self):
    if(self.head != None):
      prevNode = self.head
      tempNode = self.head
      curNode = self.head.next
      
      prevNode.next = None
      
      while(curNode != None):
        tempNode = curNode.next
        curNode.next = prevNode
        prevNode = curNode
        curNode = tempNode

      self.head = prevNode  

  #display the content of the list
  def PrintList(self):
    temp = self.head
    if(temp != None):
      print("The list contains:", end=" ")
      while (temp != None):
        print(temp.data, end=" ")
        temp = temp.next
      print()
    else:
      print("The list is empty.")

# test the code                 
MyList = LinkedList()

#Add five elements in the list.
MyList.push_back(10)
MyList.push_back(20)
MyList.push_back(30)
MyList.push_back(40)
MyList.push_back(50)

#Display the content of the list.
MyList.PrintList()

#Reversing the list.
MyList.reverseList()
  
#Display the content of the list.
MyList.PrintList()

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10 

//node structure
class Node {
    int data;
    Node next;
};

class LinkedList {
  Node head;

  LinkedList(){
    head = null;
  }

  //Add new element at the end of the list
  void push_back(int newElement) {
    Node newNode = new Node();
    newNode.data = newElement;
    newNode.next = null; 
    if(head == null) {
      head = newNode;
    } else {
      Node temp = new Node();
      temp = head;
      while(temp.next != null)
        temp = temp.next;
      temp.next = newNode;
    }    
  }

  //reverse the list
  void reverseList() {
    if(this.head != null) {
      Node prevNode = this.head;
      Node tempNode = this.head;
      Node curNode = this.head.next;
      
      prevNode.next = null;
      
      while(curNode != null) {
        tempNode = curNode.next;
        curNode.next = prevNode;
        prevNode = curNode;
        curNode = tempNode;
      }

      this.head = prevNode;
    }
  }  

  //display the content of the list
  void PrintList() {
    Node temp = new Node();
    temp = this.head;
    if(temp != null) {
      System.out.print("The list contains: ");
      while(temp != null) {
        System.out.print(temp.data + " ");
        temp = temp.next;
      }
      System.out.println();
    } else {
      System.out.println("The list is empty.");
    }
  }    
};

// test the code
public class Implementation {
  public static void main(String[] args) {
    LinkedList MyList = new LinkedList();

    //Add five elements in the list.
    MyList.push_back(10);
    MyList.push_back(20);
    MyList.push_back(30);
    MyList.push_back(40);
    MyList.push_back(50);

    //Display the content of the list.
    MyList.PrintList();

    //Reversing the list.
    MyList.reverseList();
  
    //Display the content of the list.
    MyList.PrintList();
  }
}

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10 

using System;

//node structure
class Node {
  public int data;
  public Node next;
};

class LinkedList {
  Node head;

  public LinkedList(){
    head = null;
  }
  
  //Add new element at the end of the list
  public void push_back(int newElement) {
    Node newNode = new Node();
    newNode.data = newElement;
    newNode.next = null; 
    if(head == null) {
      head = newNode;
    } else {
      Node temp = new Node();
      temp = head;
      while(temp.next != null)
        temp = temp.next;
      temp.next = newNode;
    }    
  }

  //reverse the list
  public void reverseList() {
    if(this.head != null) {
      Node prevNode = this.head;
      Node tempNode = this.head;
      Node curNode = this.head.next;
      
      prevNode.next = null;
      
      while(curNode != null) {
        tempNode = curNode.next;
        curNode.next = prevNode;
        prevNode = curNode;
        curNode = tempNode;
      }

      this.head = prevNode;
    }
  }  

  //display the content of the list
  public void PrintList() {
    Node temp = new Node();
    temp = this.head;
    if(temp != null) {
      Console.Write("The list contains: ");
      while(temp != null) {
        Console.Write(temp.data + " ");
        temp = temp.next;
      }
      Console.WriteLine();
    } else {
      Console.WriteLine("The list is empty.");
    }
  }     
};

// test the code
class Implementation {
  static void Main(string[] args) {
    LinkedList MyList = new LinkedList();

    //Add five elements in the list.
    MyList.push_back(10);
    MyList.push_back(20);
    MyList.push_back(30);
    MyList.push_back(40);
    MyList.push_back(50);

    //Display the content of the list.
    MyList.PrintList();  

    //Reversing the list.
    MyList.reverseList();
  
    //Display the content of the list.
    MyList.PrintList();
  }
}

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10 

<?php
//node structure
class Node {
  public $data;
  public $next;
}

class LinkedList {
  public $head;

  public function __construct(){
    $this->head = null;
  }
  
  //Add new element at the end of the list
  public function push_back($newElement) {
    $newNode = new Node();
    $newNode->data = $newElement;
    $newNode->next = null; 
    if($this->head == null) {
      $this->head = $newNode;
    } else {
      $temp = new Node();
      $temp = $this->head;
      while($temp->next != null) {
        $temp = $temp->next;
      }
      $temp->next = $newNode;
    }    
  }

  //reverse the list
  public function reverseList() {
    if($this->head != null) {
      $prevNode = $this->head;
      $tempNode = $this->head;
      $curNode = $this->head->next;
      
      $prevNode->next = null;
      
      while($curNode != null) {
        $tempNode = $curNode->next;
        $curNode->next = $prevNode;
        $prevNode = $curNode;
        $curNode = $tempNode;
      }

      $this->head = $prevNode;
    }
  }   

  //display the content of the list
  public function PrintList() {
    $temp = new Node();
    $temp = $this->head;
    if($temp != null) {
      echo "The list contains: ";
      while($temp != null) {
        echo $temp->data." ";
        $temp = $temp->next;
      }
      echo "\n";
    } else {
      echo "The list is empty.\n";
    }
  }   
};

// test the code 
$MyList = new LinkedList();

//Add five elements in the list.
$MyList->push_back(10);
$MyList->push_back(20);
$MyList->push_back(30);
$MyList->push_back(40);
$MyList->push_back(50);

//Display the content of the list.
$MyList->PrintList();

//Reversing the list.
$MyList->reverseList();
  
//Display the content of the list.
$MyList->PrintList();
?>

The above code will give the following output: 

The list contains: 10 20 30 40 50 
The list contains: 50 40 30 20 10
AlphaCodingSkills
AlphaCodingSkills Android App
Facebook Page Twitter Page LinkedIn Page
Learning Tutorials
Learning Tutorials
Useful Links
Python Libraries
About Us  |  Privacy Policy  |  Contact Us
AlphaCodingSkills is a online learning portal that provides tutorials on Python, Java, C++, C, C#, PHP, R, Ruby, Rust, Scala, Swift, Perl, SQL, Data Structures and Algorithms. Tutorials, examples, references and content of the website are reviewed and simplified continuously to improve comprehensibility and eliminate any possible error. We use cookies to ensure best browsing experience on our website. While using this website, you acknowledge to have read and accepted our cookie and privacy policy.