logo

TechCodeview

Kehren Sie eine verknüpfte Liste um

Bei einem Zeiger auf den Kopfknoten einer verknüpften Liste besteht die Aufgabe darin, die verknüpfte Liste umzukehren. Wir müssen die Liste umkehren, indem wir die Verknüpfungen zwischen Knoten ändern.

Beispiele :



Eingang : Kopf der folgenden verlinkten Liste
1->2->3->4->NULL
Ausgabe : Verknüpfte Liste sollte geändert werden in,
4->3->2->1->NULL

Eingang : Kopf der folgenden verlinkten Liste
1->2->3->4->5->NULL
Ausgabe : Verknüpfte Liste sollte geändert werden in,
5->4->3->2->1->NULL

Eingang : NULL
Ausgabe : NULL



Eingang : 1->NULL
Ausgabe : 1->NULL

die Zahlen des Alphabets
Empfohlene Vorgehensweise: Eine verknüpfte Liste umkehren. Probieren Sie es aus!

Kehren Sie eine verknüpfte Liste mit der iterativen Methode um:

Die Idee ist, drei Zeiger zu verwenden akt , vorher, Und nächste um den Überblick über Knoten zu behalten und Rückwärtslinks zu aktualisieren.

Führen Sie die folgenden Schritte aus, um das Problem zu lösen:



  • Initialisieren Sie drei Zeiger vorh als NULL, akt als Kopf , Und nächste als NULL.
  • Durchlaufen Sie die verknüpfte Liste. Führen Sie in einer Schleife Folgendes aus:
    • Vor dem Wechseln nächste von akt , speichern Sie die nächste Knoten
      • next = aktuell -> weiter
    • Aktualisieren Sie nun die nächste Zeiger von akt zum vorh
      • curr -> next = prev
    • Aktualisieren vorh als akt Und akt als nächste
      • prev = aktuell
      • curr = weiter

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

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->Daten = Daten;  next = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { head = NULL; } /* Funktion zum Umkehren der verknüpften Liste */ void reverse() { // Aktuelle, vorherige und nächste Zeiger initialisieren Node* current = head;  Knoten *prev = NULL, *next = NULL;  while (current != NULL) { // Store next next = current->next;  // Zeiger des aktuellen Knotens umkehren current->next = prev;  // Zeiger um eine Position nach vorne verschieben.  prev = aktuell;  aktuell = weiter;  } head = prev;  } /* Funktion zum Drucken einer verknüpften Liste */ void print() { struct Node* temp = head;  while (temp != NULL) { cout<< temp->Daten<< ' ';  temp = temp->nächste;  } } void push(int data) { Node* temp = new Node(data);  temp->next = head;  Kopf = Temperatur;  } }; /* Treibercode*/ int main() { /* Beginnen Sie mit der leeren Liste */ LinkedList ll;  ll.push(20);  ll.push(4);  ll.push(15);  ll.push(85);  cout<< '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->nächste;  // Zeiger des aktuellen Knotens umkehren current->next = prev;  // Zeiger um eine Position nach vorne verschieben.  prev = aktuell;  aktuell = weiter;  } *head_ref = prev; } /* Funktion zum Pushen eines Knotens */ void push(struct Node** head_ref, int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));  new_node->data = new_data;  new_node->next = (*head_ref);  (*head_ref) = new_node; } /* Funktion zum Drucken einer verknüpften Liste */ void printList(struct Node* head) { struct Node* temp = head;  while (temp != NULL) { printf('%d ', temp->data);  temp = temp->next;  } } /* Treibercode*/ int main() { /* Beginnen Sie mit der leeren Liste */ struct Node* head = NULL;  push(&head, 20);  push(&head, 4);  push(&head, 15);  push(&head, 85);  printf('Angegebene verknüpfte Liste
');  printList(head);  reverse(&head);  printf('
Umgekehrte verknüpfte Liste 
');  printList(head);  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 
>
Ausgabe 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Zeitkomplexität: O(N), Durchlaufen der verknüpften Liste der Größe N.
Hilfsraum: O(1)

Kehren Sie eine verknüpfte Liste mithilfe der Rekursion um:

Die Idee besteht darin, mithilfe der Rekursion den letzten Knoten der verknüpften Liste zu erreichen und dann mit der Umkehrung der verknüpften Liste zu beginnen.

Führen Sie die folgenden Schritte aus, um das Problem zu lösen:

  • Teilen Sie die Liste in zwei Teile – den ersten Knoten und den Rest der verknüpften Liste.
  • Rufen Sie „reverse“ für den Rest der verknüpften Liste auf.
  • Verknüpfen Sie zuerst die restliche verknüpfte Liste.
  • Kopfzeiger auf NULL setzen

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

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->Daten = Daten;  next = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { head = NULL; } Node* reverse(Node* head) /* Funktion zum Drucken einer verknüpften Liste */ void print() { struct Node* temp = head;  while (temp != NULL) { cout<< temp->Daten<< ' ';  temp = temp->nächste;  } } void push(int data) { Node* temp = new Node(data);  temp->next = head;  Kopf = Temperatur;  } }; /* Treiberprogramm zum Testen der obigen Funktion*/ int main() { /* Beginnen Sie mit der leeren Liste */ LinkedList ll;  ll.push(20);  ll.push(4);  ll.push(15);  ll.push(85);  cout<< '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 
>
Ausgabe 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Zeitkomplexität: O(N), jeden Knoten einmal besuchen
Hilfsraum: O(N), Funktionsaufruf-Stack-Speicherplatz

Kehren Sie eine verknüpfte Liste mit der Tail Recursive-Methode um:

Die Idee besteht darin, drei Zeiger beizubehalten vorherige , aktuell Und nächste , besuchen Sie rekursiv jeden Knoten und stellen Sie mithilfe dieser drei Zeiger Links her.

Führen Sie die folgenden Schritte aus, um das Problem zu lösen:

  • Zuerst das nächste Update mit dem nächsten aktuellen Knoten, d. h. next = aktuell->nächster
  • Erstellen Sie nun einen umgekehrten Link vom aktuellen Knoten zum vorherigen Knoten, d. h. curr->next = prev
  • Wenn der besuchte Knoten der letzte Knoten ist, erstellen Sie einfach eine Rückwärtsverbindung vom aktuellen Knoten zum vorherigen Knoten und aktualisieren Sie den Kopf.

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

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->weiter) { *head = curr;  /* Nächsten Knoten zum vorherigen Knoten aktualisieren */ curr->next = prev;  zurückkehren;  } /* curr->next Knoten für rekursiven Aufruf speichern */ Node* next = curr->next;  /* und update next ..*/ curr->next = prev;  reverseUtil(next, curr, head); } // Eine Dienstprogrammfunktion zum Drucken einer verknüpften Liste void printlist(Node* head) { while (head != NULL) { cout<< head->Daten<< ' ';  head = head->nächste;  } cout<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->next = neuer Knoten(2);  head1->next->next = new Node(3);  head1->next->next->next = new Node(4);  head1->next->next->next->next = new Node(5);  head1->next->next->next->next->next = new Node(6);  head1->next->next->next->next->next->next = new Node(7);  head1->next->next->next->next->next->next->next = new Node(8);  cout<< '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->weiter) { *head = curr;  /* Nächsten Knoten zum vorherigen Knoten aktualisieren */ curr->next = prev;  zurückkehren;  } /* curr->next Knoten für rekursiven Aufruf speichern */ Node* next = curr->next;  /* und update next ..*/ curr->next = prev;  reverseUtil(next, curr, head); } // Eine Hilfsfunktion zum Erstellen eines neuen Knotens Node* newNode(int key) { Node* temp = (Node*)malloc(sizeof(Node));  temp->data = Schlüssel;  temp->next = NULL;  Rücklauftemperatur; } // Eine Dienstprogrammfunktion zum Drucken einer verknüpften Liste void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  head = head->next;  } printf('
'); } // Treibercode int main() { Node* head1 = newNode(1);  head1->next = newNode(2);  head1->next->next = newNode(3);  head1->next->next->next = newNode(4);  head1->next->next->next->next = newNode(5);  head1->next->next->next->next->next = newNode(6);  head1->next->next->next->next->next->next = newNode(7);  head1->next->next->next->next->next->next->next = newNode(8);  printf('Angegebene verknüpfte Liste
');  printlist(head1);  reverse(&head1);  printf('Umgekehrte verknüpfte Liste
');  printlist(head1);  0 zurückgeben; } // Dieser Code wurde von Aditya Kumar (adityakumar129) beigesteuert>
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->nächster Knoten für rekursiven Aufruf */ Node next1 = curr.next;  /* und nächstes aktualisieren ..*/ curr.next = prev;  reverseUtil(next1, curr);  Rücklaufkopf;  } // druckt den Inhalt der doppelt verknüpften Liste void printList(Node node) { while (node ​​!= null) { System.out.print(node.data + ' ');  node = node.next;  } } // Treibercode public static void main(String[] args) { LinkedList list = new LinkedList();  list.head = neuer Knoten(1);  list.head.next = neuer Knoten(2);  list.head.next.next = neuer Knoten(3);  list.head.next.next.next = neuer Knoten(4);  list.head.next.next.next.next = new Node(5);  list.head.next.next.next.next.next = new Node(6);  list.head.next.next.next.next.next.next = new Node(7);  list.head.next.next.next.next.next.next.next = new Node(8);  System.out.println('Gegebene verknüpfte Liste ');  list.printList(head);  Knoten res = list.reverseUtil(head, null);  System.out.println('
Umgekehrte verknüpfte Liste ');  list.printList(res);  } } // Dieser Code wurde von Aditya Kumar (adityakumar129) beigesteuert>
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->nächster Knoten für rekursiven Aufruf */ Node next1 = curr.next;  /* und nächstes aktualisieren ..*/ curr.next = prev;  reverseUtil(next1, curr);  Rücklaufkopf;  } // druckt den Inhalt der doppelt verknüpften Liste void printList(Node node) { while (node ​​!= null) { Console.Write(node.data + ' ');  node = node.next;  } } // Treibercode public static void Main(String[] args) { LinkedList list = new LinkedList();  list.head = neuer Knoten(1);  list.head.next = neuer Knoten(2);  list.head.next.next = neuer Knoten(3);  list.head.next.next.next = neuer Knoten(4);  list.head.next.next.next.next = new Node(5);  list.head.next.next.next.next.next = new Node(6);  list.head.next.next.next.next.next.next = new Node(7);  list.head.next.next.next.next.next.next.next = new Node(8);  Console.WriteLine('Angegebene verknüpfte Liste ');  list.printList(list.head);  Knoten res = list.reverseUtil(list.head, null);  Console.WriteLine('
Umgekehrte verknüpfte Liste ');  list.printList(res);  } } // Dieser Code wurde von Rajput-Ji>'> beigesteuertJavascript>
Ausgabe 
Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1>

Zeitkomplexität: O(N), Besuch jedes Knotens der verknüpften Liste der Größe N.
Hilfsraum: O(N), Funktionsaufruf-Stack-Speicherplatz

Kehren Sie eine verknüpfte Liste um mit Die Idee besteht darin, alle Knoten im Stapel zu speichern und dann eine umgekehrt verknüpfte Liste zu erstellen.

Führen Sie die folgenden Schritte aus, um das Problem zu lösen:

  • Speichern Sie die Knoten (Werte und Adresse) im Stapel, bis alle Werte eingegeben sind.
  • Sobald alle Eingaben abgeschlossen sind, aktualisieren Sie den Head-Zeiger auf die letzte Position (d. h. den letzten Wert).
  • Beginnen Sie mit dem Popup der Knoten (Wert und Adresse) und speichern Sie sie in derselben Reihenfolge, bis der Stapel leer ist.
  • Aktualisieren Sie den nächsten Zeiger des letzten Knotens im Stapel um NULL.

Nachfolgend finden Sie die Umsetzung des oben genannten Ansatzes:

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;  Knoten* temp = *head;  while (temp->next != NULL) { // Alle Knoten in den Stapel schieben s.push(temp);  temp = temp->next;  } *head = temp;  while (!s.empty()) { // Den obersten Wert des Stapels in der Liste speichern temp->next = s.top();  // Den Wert vom Stapel holen s.pop();  // Den nächsten Zeiger in der Liste aktualisieren temp = temp->next;  } temp->next = NULL; } // Funktion zum Anzeigen der Elemente in der Liste void printlist(Node* temp) { while (temp != NULL) { cout<< temp->Daten<< ' ';  temp = temp->nächste;  } } // Programm zum Einfügen hinter der verknüpften Liste void insert_back(Node** head, int value) { // Wir haben die Methode insert at back verwendet, um Werte // in die Liste einzugeben. (z. B. head->1->2->3->4->Null) Node* temp = new Node(value);  temp->next = NULL;  // Wenn *head gleich NULL ist if (*head == NULL) { *head = temp;  zurückkehren;  } else { Node* last_node = *head;  while (last_node->next != NULL) last_node = last_node->next;  last_node->next = temp;  zurückkehren;  } } // Treibercode int main() { Node* head = NULL;  insert_back(&head, 1);  insert_back(&head, 2);  insert_back(&head, 3);  insert_back(&head, 4);  cout<< '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 = neuer Stack();  Knotentemperatur = Kopf;  while (temp.next != null) { // Alle Knoten in den Stapel schieben s.add(temp);  temp = temp.next;  } head = temp;  while (!s.isEmpty()) { // Den obersten Wert des Stapels in der Liste speichern temp.next = s.peek();  // Den Wert vom Stapel holen s.pop();  // Den nächsten Zeiger in der Liste aktualisieren temp = temp.next;  } temp.next = null;  } // Funktion zum Anzeigen der Elemente in der Liste static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.next;  } } // Programm zum Einfügen hinter der verknüpften Liste static void insert_back(int value) { // Wir haben die Methode insert at back verwendet, um // Werte in die Liste einzugeben. (z. B. head.1.2.3.4.Null) Knoten temp = neuer Knoten(Wert);  temp.next = null;  // Wenn *head gleich null ist if (head == null) { head = temp;  zurückkehren;  } else { Node last_node = head;  while (last_node.next != null) last_node = last_node.next;  last_node.next = temp;  zurückkehren;  } } // Treibercode public static void main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  System.out.print('Angegebene verknüpfte Liste
');  printlist(head);  reverseLL();  System.out.print('
Umgekehrte verknüpfte Liste
');  printlist(head);  } } // Dieser Code wurde von Aditya Kumar (adityakumar129) beigesteuert>
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 = None return head # Driver Code if __name__ == '__main__': head = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print('Gegebene verknüpfte Liste') temp = head while temp: print(temp.val, end=' ') temp = temp.next obj = Solution() print(' 
Umgekehrte verknüpfte Liste') 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 = neuer Stapel();  Knotentemperatur = Kopf;  while (temp.next != null) { // Alle Knoten // in den Stapel schieben s.Push(temp);  temp = temp.next;  } head = temp;  while (s.Count != 0) { // Den obersten Wert des // Stapels in der Liste speichern temp.next = s.Peek();  // Den Wert vom Stapel holen s.Pop();  // Den nächsten Zeiger in der // Liste aktualisieren temp = temp.next;  } temp.next = null;  } // Funktion zum Anzeigen // der Elemente in der Liste static void printlist(Node temp) { while (temp != null) { Console.Write(temp.data + ' ');  temp = temp.next;  } } // Funktion zum Einfügen hinter der // verknüpften Liste static void insert_back(int val) { // Wir haben die Einfügungsmethode // verwendet, um Werte in die Liste einzugeben. (z. B.: // head.1.2.3.4 .Null) Node temp = new Node(val);  temp.next = null;  // Wenn *head gleich null ist if (head == null) { head = temp;  zurückkehren;  } else { Node last_node = head;  while (last_node.next != null) { last_node = last_node.next;  } last_node.next = temp;  zurückkehren;  } } // Treibercode public static void Main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  Console.Write('Angegebene verknüpfte Liste
');  printlist(head);  reverseLL();  Console.Write('
Umgekehrte verknüpfte Liste
');  printlist(head);  } } // Dieser Code wurde von gauravrajput1>'> beigesteuertJavascript>
Ausgabe 
Given linked list 1 2 3 4 Reversed linked list 4 3 2 1>

Zeitkomplexität: O(N), Besuch jedes Knotens der verknüpften Liste der Größe N.
Hilfsraum: O(N), Space wird zum Speichern der Knoten im Stapel verwendet.