logo

TechCodeview

Een gekoppelde lijst omkeren

Gegeven een verwijzing naar het hoofdknooppunt van een gekoppelde lijst, is het de taak om de gekoppelde lijst om te keren. We moeten de lijst omkeren door de koppelingen tussen knooppunten te wijzigen.

Voorbeelden :



Invoer : Hoofd van de volgende gekoppelde lijst
1->2->3->4->NUL
Uitvoer : Gelinkte lijst moet worden gewijzigd in,
4->3->2->1->NUL

Invoer : Hoofd van de volgende gekoppelde lijst
1->2->3->4->5->NULL
Uitvoer : Gelinkte lijst moet worden gewijzigd in,
5->4->3->2->1->NULL

Invoer : NUL
Uitvoer : NUL



Invoer : 1->NULL
Uitvoer : 1->NULL

Aanbevolen praktijk Een gekoppelde lijst omkeren Probeer het!

Keer een gekoppelde lijst om via de iteratieve methode:

Het idee is om drie wijzers te gebruiken kr , vorige, En volgende om knooppunten bij te houden om omgekeerde links bij te werken.

Volg de onderstaande stappen om het probleem op te lossen:



  • Initialiseer drie wijzers vorige als NULL, kr als hoofd , En volgende als NUL.
  • Herhaal de gekoppelde lijst. Doe het volgende in een lus:
    • Voordat u de volgende van kr , bewaar de volgende knooppunt
      • volgende = huidige -> volgende
    • Werk nu de volgende wijzer van kr naar de vorige
      • huidige -> volgende = vorige
    • Update vorige als kr En kr als volgende
      • vorige = huidige
      • huidige = volgende

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++ 
// Iterative C++ program to reverse a linked list #include  using namespace std; /* Link list node */ struct Node {  int data;  struct Node* next;  Node(int data)  {  this->gegevens = gegevens;  volgende = NULL;  } }; struct LinkedList { Knooppunt* hoofd;  LinkedList() {head = NULL; } /* Functie om de gekoppelde lijst om te keren */ void reverse() {// Initialiseer huidige, vorige en volgende verwijzingen Knooppunt* current = head;  Knooppunt *prev = NULL, *next = NULL;  while (huidig!= NULL) {// Bewaar volgende volgende = huidige->volgende;  // Draai de aanwijzer van het huidige knooppunt om huidige->volgende = vorige;  // Verplaats de wijzers één positie vooruit.  vorige = huidig;  huidige = volgende;  } hoofd = vorige;  } /* Functie om gekoppelde lijst af te drukken */ void print() { struct Node* temp = head;  terwijl (temp != NULL) { cout<< temp->gegevens<< ' ';  temp = temp->volgende;  } } void push(int data) { Node* temp = new Node(data);  temp->volgende = hoofd;  hoofd = temperatuur;  } }; /* Stuurprogrammacode*/ int main() {/ /* Begin met de lege lijst */ LinkedList ll;  ll.push(20);  ll.push(4);  ll.push(15);  ll.push(85);  uit<< 'Given linked list
';  ll.print();  ll.reverse();  cout << '
Reversed linked list 
';  ll.print();  return 0; }>
C 
// Iterative C program to reverse a linked list #include  #include  /* Link list node */ struct Node {  int data;  struct Node* next; }; /* Function to reverse the linked list */ static void reverse(struct Node** head_ref) {  struct Node* prev = NULL;  struct Node* current = *head_ref;  struct Node* next = NULL;  while (current != NULL) {  // Store next  next = current->volgende;  // Draai de aanwijzer van het huidige knooppunt om huidige->volgende = vorige;  // Verplaats de wijzers één positie vooruit.  vorige = huidig;  huidige = volgende;  } *head_ref = vorige; } /* Functie om een ​​knooppunt te pushen */ void push(struct Node** head_ref, int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));  nieuwe_node->data = nieuwe_data;  new_node->volgende = (*head_ref);  (*head_ref) = nieuw_knooppunt; } /* Functie om gekoppelde lijst af te drukken */ void printList(struct Node* head) { struct Node* temp = head;  while (temp != NULL) { printf('%d ', temp->data);  temp = temp->volgende;  } } /* Stuurprogrammacode*/ int main() { /* Begin met de lege lijst */ struct Node* head = NULL;  duwen(&hoofd, 20);  duwen(&hoofd, 4);  duwen(&hoofd, 15);  push(&hoofd, 85);  printf('Gegeven gekoppelde lijst
');  printLijst(hoofd);  achteruit(&hoofd);  printf('
Omgekeerde gekoppelde lijst 
');  printLijst(hoofd);  getchar(); }>
Java 
// Java program for reversing the linked list class LinkedList {  static Node head;  static class Node {  int data;  Node next;  Node(int d)  {  data = d;  next = null;  }  }  /* Function to reverse the linked list */  Node reverse(Node node)  {  Node prev = null;  Node current = node;  Node next = null;  while (current != null) {  next = current.next;  current.next = prev;  prev = current;  current = next;  }  node = prev;  return node;  }  // prints content of double linked list  void printList(Node node)  {  while (node != null) {  System.out.print(node.data + ' ');  node = node.next;  }  }  // Driver Code  public static void main(String[] args)  {  LinkedList list = new LinkedList();  list.head = new Node(85);  list.head.next = new Node(15);  list.head.next.next = new Node(4);  list.head.next.next.next = new Node(20);  System.out.println('Given linked list');  list.printList(head);  head = list.reverse(head);  System.out.println('');  System.out.println('Reversed linked list ');  list.printList(head);  } } // This code has been contributed by Mayank Jaiswal>
Python 
# Python program to reverse a linked list # Time Complexity : O(n) # Space Complexity : O(1) # Node class class Node: # Constructor to initialize the node object def __init__(self, data): self.data = data self.next = None class LinkedList: # Function to initialize head def __init__(self): self.head = None # Function to reverse the linked list def reverse(self): prev = None current = self.head while(current is not None): next = current.next current.next = prev prev = current current = next self.head = prev # Function to insert a new node at the beginning def push(self, new_data): new_node = Node(new_data) new_node.next = self.head self.head = new_node # Utility function to print the LinkedList def printList(self): temp = self.head while(temp): print(temp.data, end=' ') temp = temp.next # Driver code llist = LinkedList() llist.push(20) llist.push(4) llist.push(15) llist.push(85) print ('Given linked list') llist.printList() llist.reverse() print ('
Reversed linked list') llist.printList() # This code is contributed by Nikhil Kumar Singh(nickzuck_007)>
C# 
// C# program for reversing the linked list using System; class GFG {  // Driver Code  static void Main(string[] args)  {  LinkedList list = new LinkedList();  list.AddNode(new LinkedList.Node(85));  list.AddNode(new LinkedList.Node(15));  list.AddNode(new LinkedList.Node(4));  list.AddNode(new LinkedList.Node(20));  // List before reversal  Console.WriteLine('Given linked list ');  list.PrintList();  // Reverse the list  list.ReverseList();  // List after reversal  Console.WriteLine('Reversed linked list ');  list.PrintList();  } } class LinkedList {  Node head;  public class Node {  public int data;  public Node next;  public Node(int d)  {  data = d;  next = null;  }  }  // function to add a new node at  // the end of the list  public void AddNode(Node node)  {  if (head == null)  head = node;  else {  Node temp = head;  while (temp.next != null) {  temp = temp.next;  }  temp.next = node;  }  }  // function to reverse the list  public void ReverseList()  {  Node prev = null, current = head, next = null;  while (current != null) {  next = current.next;  current.next = prev;  prev = current;  current = next;  }  head = prev;  }  // function to print the list data  public void PrintList()  {  Node current = head;  while (current != null) {  Console.Write(current.data + ' ');  current = current.next;  }  Console.WriteLine();  } } // This code is contributed by Mayank Sharma>
Javascript 
>
Uitvoer 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Tijdcomplexiteit: O(N), Doorkruisen van de gekoppelde lijst van maat N.
Hulpruimte: O(1)

Een gekoppelde lijst omkeren met behulp van recursie:

Het idee is om het laatste knooppunt van de gekoppelde lijst te bereiken met behulp van recursie en vervolgens te beginnen met het omkeren van de gekoppelde lijst.

Volg de onderstaande stappen om het probleem op te lossen:

  • Verdeel de lijst in twee delen: het eerste knooppunt en de rest van de gekoppelde lijst.
  • Bel omgekeerd voor de rest van de gekoppelde lijst.
  • Koppel de rest van de gekoppelde lijst eerst.
  • Herstel de hoofdaanwijzer naar NULL

Hieronder vindt u de implementatie van bovenstaande aanpak:

C++ 
// Recursive C++ program to reverse // a linked list #include  using namespace std; /* Link list node */ struct Node {  int data;  struct Node* next;  Node(int data)  {  this->gegevens = gegevens;  volgende = NULL;  } }; struct LinkedList { Knooppunt* hoofd;  LinkedList() {head = NULL; } Knooppunt* reverse(Knooppunt* hoofd) /* Functie om gekoppelde lijst af te drukken */ void print() { struct Knooppunt* temp = hoofd;  terwijl (temp != NULL) { cout<< temp->gegevens<< ' ';  temp = temp->volgende;  } } void push(int data) { Node* temp = new Node(data);  temp->volgende = hoofd;  hoofd = temperatuur;  } }; /* Stuurprogramma om bovenstaande functie te testen*/ int main() {//* Begin met de lege lijst */ LinkedList ll;  ll.push(20);  ll.push(4);  ll.push(15);  ll.push(85);  uit<< 'Given linked list
';  ll.print();  ll.head = ll.reverse(ll.head);  cout << '
Reversed linked list 
';  ll.print();  return 0; }>
Java 
// Recursive Java program to reverse // a linked list import java.io.*; class recursion {  static Node head; // head of list  static class Node {  int data;  Node next;  Node(int d)  {  data = d;  next = null;  }  }  static Node reverse(Node head)    /* Function to print linked list */  static void print()  {  Node temp = head;  while (temp != null) {  System.out.print(temp.data + ' ');  temp = temp.next;  }  System.out.println();  }  static void push(int data)  {  Node temp = new Node(data);  temp.next = head;  head = temp;  }  /* Driver program to test above function*/  public static void main(String args[])  {  /* Start with the empty list */  push(20);  push(4);  push(15);  push(85);  System.out.println('Given linked list');  print();  head = reverse(head);  System.out.println('Reversed linked list');  print();  } } // This code is contributed by Prakhar Agarwal>
Python 
'''Python3 program to reverse linked list using recursive method''' # Linked List Node class Node: def __init__(self, data): self.data = data self.next = None # Create and Handle list operations class LinkedList: def __init__(self): self.head = None # Head of list # Method to reverse the list def reverse(self, head): # If head is empty or has reached the list end if head is None or head.next is None: return head # Reverse the rest list rest = self.reverse(head.next) # Put first element at the end head.next.next = head head.next = None # Fix the header pointer return rest # Returns the linked list in display format def __str__(self): linkedListStr = '' temp = self.head while temp: linkedListStr = (linkedListStr + str(temp.data) + ' ') temp = temp.next return linkedListStr # Pushes new data to the head of the list def push(self, data): temp = Node(data) temp.next = self.head self.head = temp # Driver code linkedList = LinkedList() linkedList.push(20) linkedList.push(4) linkedList.push(15) linkedList.push(85) print('Given linked list') print(linkedList) linkedList.head = linkedList.reverse(linkedList.head) print('Reversed linked list') print(linkedList) # This code is contributed by Debidutta Rath>
C# 
// Recursive C# program to // reverse a linked list using System; class recursion {  // Head of list  static Node head;  public class Node {  public int data;  public Node next;  public Node(int d)  {  data = d;  next = null;  }  }  static Node reverse(Node head)    if (head == null   // Function to print linked list  static void print()  {  Node temp = head;  while (temp != null) {  Console.Write(temp.data + ' ');  temp = temp.next;  }  Console.WriteLine();  }  static void push(int data)  {  Node temp = new Node(data);  temp.next = head;  head = temp;  }  // Driver code  public static void Main(String[] args)  {  // Start with the  // empty list  push(20);  push(4);  push(15);  push(85);  Console.WriteLine('Given linked list');  print();  head = reverse(head);  Console.WriteLine('Reversed linked list');  print();  } } // This code is contributed by gauravrajput1>
Javascript 
>
Uitvoer 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Tijdcomplexiteit: O(N), Elk knooppunt één keer bezoeken
Hulpruimte: O(N), Functieaanroepstapelruimte

Keer een gekoppelde lijst om met de Tail Recursive Method:

Het idee is om drie punten te behouden vorig , huidig En volgende , bezoek recursief elk knooppunt en maak koppelingen met behulp van deze drie pointers.

Volg de onderstaande stappen om het probleem op te lossen:

  • Eerste update volgende met volgende knooppunt van stroom, d.w.z. volgende = huidige->volgende
  • Maak nu een omgekeerde link van het huidige knooppunt naar het vorige knooppunt, d.w.z. curr->volgende = vorige
  • Als het bezochte knooppunt het laatste knooppunt is, maak dan gewoon een omgekeerde link van het huidige knooppunt naar het vorige knooppunt en update de kop.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

Java-verbeterde lus
C++ 
// A simple and tail recursive C++ program to reverse // a linked list #include  using namespace std; struct Node {  int data;  struct Node* next;  Node(int x) {  data = x;  next = NULL;  } }; void reverseUtil(Node* curr, Node* prev, Node** head); // This function mainly calls reverseUtil() // with prev as NULL void reverse(Node** head) {  if (!head)  return;  reverseUtil(*head, NULL, head); } // A simple and tail-recursive function to reverse // a linked list. prev is passed as NULL initially. void reverseUtil(Node* curr, Node* prev, Node** head) {  /* If last node mark it head*/  if (!curr->volgende) { *hoofd = huidige;  /* Update naast vorig knooppunt */ curr->next = prev;  opbrengst;  } /* Bewaar huidige->volgende knoop voor recursieve aanroep */ Knooppunt* volgende = huidige->volgende;  /* en update volgende ..*/ curr->volgende = vorige;  reverseUtil(volgende, curr, hoofd); } // Een hulpprogrammafunctie om een ​​gekoppelde lijst af te drukken void printlist(Node* head) { while (head != NULL) { cout<< head->gegevens<< ' ';  head = head->volgende;  } uit<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->volgende = nieuw knooppunt(2);  head1->volgende->volgende = nieuw knooppunt(3);  head1->volgende->volgende->volgende = nieuw knooppunt(4);  head1->volgende->volgende->volgende->volgende = nieuw knooppunt(5);  head1->volgende->volgende->volgende->volgende->volgende = nieuw knooppunt(6);  head1->volgende->volgende->volgende->volgende->volgende->volgende = nieuw knooppunt(7);  head1->volgende->volgende->volgende->volgende->volgende->volgende->volgende = nieuw knooppunt(8);  uit<< 'Given linked list
';  printlist(head1);  reverse(&head1);  cout << 'Reversed linked list
';  printlist(head1);  return 0; }>
C 
// A simple and tail recursive C program to reverse a linked // list #include  #include  typedef struct Node {  int data;  struct Node* next; } Node; void reverseUtil(Node* curr, Node* prev, Node** head); // This function mainly calls reverseUtil() // with prev as NULL void reverse(Node** head) {  if (!head)  return;  reverseUtil(*head, NULL, head); } // A simple and tail-recursive function to reverse // a linked list. prev is passed as NULL initially. void reverseUtil(Node* curr, Node* prev, Node** head) {  /* If last node mark it head*/  if (!curr->volgende) { *hoofd = huidige;  /* Update naast vorig knooppunt */ curr->next = prev;  opbrengst;  } /* Bewaar huidige->volgende knoop voor recursieve aanroep */ Knooppunt* volgende = huidige->volgende;  /* en update volgende ..*/ curr->volgende = vorige;  reverseUtil(volgende, curr, hoofd); } // Een hulpprogrammafunctie om een ​​nieuw knooppunt te maken. Node* newNode(int key) { Node* temp = (Node*)malloc(sizeof(Node));  temp->data = sleutel;  temp->volgende = NULL;  retourtemperatuur; } // Een hulpprogrammafunctie om een ​​gekoppelde lijst af te drukken void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  hoofd = hoofd->volgende;  } printf('
'); } // Stuurprogrammacode int main() { Knooppunt* head1 = newNode(1);  head1->volgende = newNode(2);  head1->volgende->volgende = newNode(3);  head1->volgende->volgende->volgende = newNode(4);  head1->volgende->volgende->volgende->volgende = newNode(5);  head1->volgende->volgende->volgende->volgende->volgende = newNode(6);  head1->volgende->volgende->volgende->volgende->volgende->volgende = newNode(7);  head1->volgende->volgende->volgende->volgende->volgende->volgende->volgende = newNode(8);  printf('Gegeven gekoppelde lijst
');  afdruklijst(head1);  achteruit(&head1);  printf('Omgekeerde gekoppelde lijst
');  afdruklijst(head1);  retour 0; } // Deze code is bijgedragen door Aditya Kumar (adityakumar129)>
Java 
// Java program for reversing the Linked list class LinkedList {  static Node head;  static class Node {  int data;  Node next;  Node(int d)  {  data = d;  next = null;  }  }  // A simple and tail recursive function to reverse  // a linked list. prev is passed as NULL initially.  Node reverseUtil(Node curr, Node prev)  {  /*If head is initially null OR list is empty*/  if (head == null)  return head;  /* If last node mark it head*/  if (curr.next == null) {  head = curr;  /* Update next to prev node */  curr.next = prev;  return head;  }  /* Save curr->volgend knooppunt voor recursieve oproep */ Knooppunt next1 = curr.next;  /* en update volgende ..*/ curr.next = vorige;  reverseUtil(volgende1, curr);  terugkeer hoofd;  } // drukt de inhoud van een dubbel gelinkte lijst af void printList(Node node) { while (node ​​!= null) { System.out.print(node.data + ' ');  knooppunt = knooppunt.volgende;  } } // Stuurprogrammacode public static void main(String[] args) { LinkedList lijst = new LinkedList();  list.head = nieuw knooppunt (1);  list.head.next = nieuw knooppunt (2);  list.head.next.next = nieuw knooppunt(3);  list.head.next.next.next = nieuw knooppunt (4);  list.head.next.next.next.next = nieuw knooppunt (5);  list.head.next.next.next.next.next = nieuw knooppunt (6);  list.head.next.next.next.next.next.next = nieuw knooppunt (7);  list.head.next.next.next.next.next.next.next = nieuw knooppunt (8);  System.out.println('Gegeven gekoppelde lijst');  lijst.printList(hoofd);  Knooppunt res = lijst.reverseUtil(head, null);  System.out.println('
Omgekeerde gekoppelde lijst ');  lijst.printList(res);  } } // Deze code is bijgedragen door Aditya Kumar (adityakumar129)>
Python 
# Simple and tail recursive Python program to # reverse a linked list # Node class class Node: # Constructor to initialize the node object def __init__(self, data): self.data = data self.next = None class LinkedList: # Function to initialize head def __init__(self): self.head = None def reverseUtil(self, curr, prev): # If last node mark it head if curr.next is None: self.head = curr # Update next to prev node curr.next = prev return # Save curr.next node for recursive call next = curr.next # And update next curr.next = prev self.reverseUtil(next, curr) # This function mainly calls reverseUtil() # with previous as None def reverse(self): if self.head is None: return self.reverseUtil(self.head, None) # Function to insert a new node at the beginning def push(self, new_data): new_node = Node(new_data) new_node.next = self.head self.head = new_node # Utility function to print the linked LinkedList def printList(self): temp = self.head while(temp): print (temp.data, end=' ') temp = temp.next # Driver code llist = LinkedList() llist.push(8) llist.push(7) llist.push(6) llist.push(5) llist.push(4) llist.push(3) llist.push(2) llist.push(1) print ('Given linked list') llist.printList() llist.reverse() print ('
Reversed linked list') llist.printList() # This code is contributed by Nikhil Kumar Singh(nickzuck_007)>
C# 
// C# program for reversing the Linked list using System; public class LinkedList {  Node head;  public class Node {  public int data;  public Node next;  public Node(int d)  {  data = d;  next = null;  }  }  // A simple and tail-recursive function to reverse  // a linked list. prev is passed as NULL initially.  Node reverseUtil(Node curr, Node prev)  {  /* If last node mark it head*/  if (curr.next == null) {  head = curr;  /* Update next to prev node */  curr.next = prev;  return head;  }  /* Save curr->volgend knooppunt voor recursieve oproep */ Knooppunt next1 = curr.next;  /* en update volgende ..*/ curr.next = vorige;  reverseUtil(volgende1, curr);  terugkeer hoofd;  } // drukt de inhoud van een dubbel gelinkte lijst af void printList(Node node) { while (node ​​!= null) { Console.Write(node.data + ' ');  knooppunt = knooppunt.volgende;  } } // Stuurprogrammacode public static void Main(String[] args) { LinkedList-lijst = new LinkedList();  list.head = nieuw knooppunt (1);  list.head.next = nieuw knooppunt (2);  list.head.next.next = nieuw knooppunt(3);  list.head.next.next.next = nieuw knooppunt (4);  list.head.next.next.next.next = nieuw knooppunt (5);  list.head.next.next.next.next.next = nieuw knooppunt (6);  list.head.next.next.next.next.next.next = nieuw knooppunt (7);  list.head.next.next.next.next.next.next.next = nieuw knooppunt (8);  Console.WriteLine('Gegeven gekoppelde lijst');  lijst.printList(lijst.head);  Knooppunt res = lijst.reverseUtil(lijst.head, null);  Console.WriteLine('
Omgekeerde gekoppelde lijst ');  lijst.printList(res);  } } // Deze code is bijgedragen door Rajput-Ji>
Javascript 
>
Uitvoer 
Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1>

Tijdcomplexiteit: O(N), Elk knooppunt van de gekoppelde lijst met maat N bezoeken.
Hulpruimte: O(N), Functieaanroepstapelruimte

Een gekoppelde lijst omkeren met behulp van Het idee is om alle knooppunten in de stapel op te slaan en vervolgens een omgekeerd gekoppelde lijst te maken.

Volg de onderstaande stappen om het probleem op te lossen:

  • Bewaar de knooppunten (waarden en adres) in de stapel totdat alle waarden zijn ingevoerd.
  • Zodra alle invoer is voltooid, werkt u de hoofdaanwijzer bij naar de laatste locatie (dat wil zeggen de laatste waarde).
  • Begin met het plaatsen van de knooppunten (waarde en adres) en bewaar ze in dezelfde volgorde totdat de stapel leeg is.
  • Update de volgende aanwijzer van het laatste knooppunt in de stapel met NULL.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

C++ 
// C++ program for above approach #include  #include  using namespace std; // Create a class Node to enter values and address in the // list class Node { public:  int data;  Node* next;  Node(int x) {  data = x;  next = NULL;  } }; // Function to reverse the linked list void reverseLL(Node** head) {  // Create a stack 's' of Node type  stackS;  Knooppunt* temp = *head;  while (temp->next != NULL) {// Duw alle knooppunten naar binnen om s.push(temp);  temp = temp->volgende;  } *hoofd = temperatuur;  while (!s.empty()) {// Bewaar de bovenste waarde van de stapel in de lijst temp->next = s.top();  // Haal de waarde uit stapel s.pop();  // update de volgende aanwijzer in de lijst temp = temp->next;  } temp->volgende = NULL; } // Functie om de elementen in de lijst weer te geven void printlist(Node* temp) { while (temp != NULL) { cout<< temp->gegevens<< ' ';  temp = temp->volgende;  } } // Programma om de achterkant van de gekoppelde lijst in te voegen void insert_back(Node** head, int value) {// we hebben de invoegmethode achteraan gebruikt om waarden // in de lijst in te voeren. (bijv.: head->1->2->3->4->Null) Knooppunt* temp = nieuw knooppunt (waarde);  temp->volgende = NULL;  // If *head is gelijk aan NULL if (*head == NULL) { *head = temp;  opbrengst;  } else { Knooppunt* laatste_knooppunt = *head;  while (laatste_knooppunt->volgende != NULL) laatste_knooppunt = laatste_knooppunt->volgende;  last_node->volgende = temperatuur;  opbrengst;  } } // Stuurprogrammacode int main() { Knooppunt* head = NULL;  insert_back(&head, 1);  insert_back(&head, 2);  insert_back(&head, 3);  insert_back(&head, 4);  uit<< 'Given linked list
';  printlist(head);  reverseLL(&head);  cout << '
Reversed linked list
';  printlist(head);  return 0; } // This code is contributed by Aditya Kumar (adityakumar129)>
Java 
// Java program for above approach import java.util.*; class GFG {  // Create a class Node to enter values and address in  // the list  static class Node {  int data;  Node next;  Node(int x) {  data = x;  next = null;  }  };  static Node head = null;  // Function to reverse the linked list  static void reverseLL()  {  // Create a stack 's' of Node type  Stacks = nieuwe stapel();  Knooppunttemperatuur = hoofd;  while (temp.next!= null) {// Duw alle knooppunten naar binnen om s.add(temp);  temp = temp.volgende;  } hoofd = temperatuur;  while (!s.isEmpty()) {// Bewaar de bovenste waarde van de stapel in de lijst temp.next = s.peek();  // Haal de waarde uit stapel s.pop();  // update de volgende aanwijzer in de lijst temp = temp.next;  } temp.volgende = nul;  } // Functie om de elementen in de lijst weer te geven static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.volgende;  } } // Programma om de achterkant van de gekoppelde lijst in te voegen static void insert_back(int value) {// we hebben de invoegmethode achteraan gebruikt om // waarden in de lijst in te voeren. (bijv.: head.1.2.3.4.Null) Knooppunt temp = nieuw knooppunt (waarde);  temp.volgende = nul;  // If *head is gelijk aan null if (head == null) { head = temp;  opbrengst;  } else { Knooppunt last_node = hoofd;  while (laatste_knooppunt.next != null) laatste_knooppunt = laatste_knooppunt.next;  last_node.next = temperatuur;  opbrengst;  } } // Stuurprogrammacode public static void main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  System.out.print('Gegeven gekoppelde lijst
');  afdruklijst(hoofd);  omgekeerdeLL();  System.out.print('
Omgekeerde gekoppelde lijst
');  afdruklijst(hoofd);  } } // Deze code is bijgedragen door Aditya Kumar (adityakumar129)>
Python 
# Python code for the above approach # Definition for singly-linked list. class ListNode: def __init__(self, val = 0, next=None): self.val = val self.next = next class Solution: # Program to reverse the linked list # using stack def reverseLLUsingStack(self, head): # Initialise the variables stack, temp = [], head while temp: stack.append(temp) temp = temp.next head = temp = stack.pop() # Until stack is not # empty while len(stack)>0: temp.next = stack.pop() temp = temp.next temp.next = Geen return head # Stuurprogrammacode if __name__ == '__main__': head = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print('Gegeven gekoppelde lijst') temp = head while temp: print(temp.val, end=' ') temp = temp.next obj = Solution() print(' 
Omgekeerde gekoppelde lijst') head = obj.reverseLLUsingStack(head) while head: print(head.val, end=' ') head = head.next>
C# 
// C# program for above approach using System; using System.Collections.Generic; class GFG {  // Create a class Node to enter  // values and address in the list  public class Node {  public int data;  public Node next;  public Node(int x) {  data = x;  }  };  static Node head = null;  // Function to reverse the  // linked list  static void reverseLL()  {  // Create a stack 's'  // of Node type  Stacks = nieuwe stapel();  Knooppunttemperatuur = hoofd;  while (temp.next!= null) {// Duw alle knooppunten // in om s.Push(temp);  temp = temp.volgende;  } hoofd = temperatuur;  while (s.Count != 0) {// Bewaar de bovenste waarde van // stack in lijst temp.next = s.Peek();  // Haal de waarde uit stapel s.Pop();  // Update de volgende pointer in // in de lijst temp = temp.next;  } temp.volgende = nul;  } // Weer te geven functie // de elementen in de lijst static void printlist (Node temp) { while (temp != null) { Console.Write (temp.data + ' ');  temp = temp.volgende;  } } // Functie om de achterkant van de // gekoppelde lijst in te voegen static void insert_back(int val) {// We hebben de methode voor invoegen achteraan gebruikt // om waarden in de lijst in te voeren. (bijv.: // head.1.2.3.4 .Null) Knooppunttemperatuur = nieuw knooppunt (val);  temp.volgende = nul;  // If *head is gelijk aan null if (head == null) { head = temp;  opbrengst;  } else { Knooppunt last_node = hoofd;  while (laatste_knooppunt.next!= null) {laatste_knooppunt = laatste_knooppunt.next;  } last_node.next = temperatuur;  opbrengst;  } } // Stuurprogrammacode public static void Main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  Console.Write('Gegeven gekoppelde lijst
');  afdruklijst(hoofd);  omgekeerdeLL();  Console.Write('
Omgekeerde gekoppelde lijst
');  afdruklijst(hoofd);  } } // Deze code is bijgedragen door gauravrajput1>
Javascript 
>
Uitvoer 
Given linked list 1 2 3 4 Reversed linked list 4 3 2 1>

Tijdcomplexiteit: O(N), Elk knooppunt van de gekoppelde lijst met maat N bezoeken.
Hulpruimte: O(N), Ruimte wordt gebruikt om de knooppunten in de stapel op te slaan.