logo

TechCodeview

Omvänd en länkad lista

Givet en pekare till huvudnoden för en länkad lista, är uppgiften att vända den länkade listan. Vi måste vända listan genom att ändra länkarna mellan noder.

Exempel :



Inmatning : Chef för följande länkade lista
1->2->3->4->NULL
Produktion : Länkad lista bör ändras till,
4->3->2->1->NULL

Inmatning : Chef för följande länkade lista
1->2->3->4->5->NULL
Produktion : Länkad lista bör ändras till,
5->4->3->2->1->NULL

Inmatning : NULL
Produktion : NULL



Inmatning : 1->NULL
Produktion : 1->NULL

Rekommenderad praxis Vänd en länkad lista Prova det!

Omvänd en länkad lista med iterativ metod:

Tanken är att använda tre pekare curr , föregående, och Nästa för att hålla reda på noder för att uppdatera omvända länkar.

Följ stegen nedan för att lösa problemet:



  • Initiera tre pekare föregående som NULL, curr som huvud , och Nästa som NULL.
  • Iterera genom den länkade listan. Gör följande i en loop:
    • Innan du ändrar Nästa av curr , lagra Nästa nod
      • nästa = curr -> nästa
    • Uppdatera nu Nästa pekare av curr till föregående
      • curr -> nästa = föregående
    • Uppdatering föregående som curr och curr som Nästa
      • föregående = curr
      • curr = nästa

Nedan är implementeringen av ovanstående tillvägagångssätt:

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->data = data;  nästa = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { head = NULL; } /* Funktion för att vända den länkade listan */ void reverse() { // Initiera aktuella, föregående och nästa pekare Node* aktuell = huvud;  Nod *prev = NULL, *next = NULL;  while (current != NULL) { // Store next next = current->next;  // Vänd strömnodens pekare ström->nästa = föregående;  // Flytta pekarna en position framåt.  föregående = nuvarande;  nuvarande = nästa;  } huvud = föregående;  } /* Funktion för att skriva ut länkad lista */ void print() { struct Node* temp = head;  while (temp != NULL) { cout<< temp->data<< ' ';  temp = temp->Nästa;  } } void push(int data) { Node* temp = new Node(data);  temp->nästa = huvud;  huvud = temp;  } }; /* Drivrutinskod*/ int main() { /* Börja med den tomma listan */ 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ästa;  // Vänd strömnodens pekare ström->nästa = föregående;  // Flytta pekarna en position framåt.  föregående = nuvarande;  nuvarande = nästa;  } *head_ref = föregående; } /* Funktion för att pusha en nod */ 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);  (*huvud_ref) = ny_nod; } /* Funktion för att skriva ut länkad lista */ void printList(struct Node* head) { struct Node* temp = head;  while (temp != NULL) { printf('%d ', temp->data);  temp = temp->nästa;  } } /* Drivrutinskod*/ int main() { /* Börja med den tomma listan */ struct Node* head = NULL;  push(&head, 20);  push(&huvud, 4);  push(&head, 15);  push(&head, 85);  printf('Given länkad lista
');  printList(huvud);  reverse(&head);  printf('
Omvänd länkad lista 
');  printList(huvud);  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>
Pytonorm 
# 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 
>
Produktion 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Tidskomplexitet: O(N), gå över den länkade listan med storlek N.
Hjälputrymme: O(1)

Omvänd en länkad lista med Rekursion:

Tanken är att nå den sista noden i den länkade listan med hjälp av rekursion och sedan börja vända på den länkade listan.

Följ stegen nedan för att lösa problemet:

  • Dela listan i två delar – första noden och resten av den länkade listan.
  • Ring omvänd för resten av den länkade listan.
  • Länka resten länkade listan till först.
  • Fixa huvudpekaren till NULL

Nedan är implementeringen av ovanstående tillvägagångssätt:

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->data = data;  nästa = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { head = NULL; } Node* reverse(Node* head) /* Funktion för att skriva ut länkad lista */ void print() { struct Node* temp = head;  while (temp != NULL) { cout<< temp->data<< ' ';  temp = temp->Nästa;  } } void push(int data) { Node* temp = new Node(data);  temp->nästa = huvud;  huvud = temp;  } }; /* Drivrutinsprogram för att testa ovanstående funktion*/ int main() { /* Börja med den tomma listan */ 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>
Pytonorm 
'''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 
>
Produktion 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Tidskomplexitet: O(N), besöker varje nod en gång
Hjälputrymme: O(N), stackutrymme för funktionsanrop

Omvänd en länkad lista med Tail Rekursiv metod:

Tanken är att behålla tre pekare tidigare , nuvarande och Nästa , besök varje nod rekursivt och skapa länkar med dessa tre pekare.

Följ stegen nedan för att lösa problemet:

  • Första uppdateringen nästa med nästa nod av nuvarande, dvs. nästa = nuvarande->nästa
  • Gör nu en omvänd länk från nuvarande nod till föregående nod, dvs curr->next = prev
  • Om den besökta noden är den sista noden gör du bara en omvänd länk från den nuvarande noden till föregående nod och uppdateringshuvud.

Nedan är implementeringen av ovanstående tillvägagångssätt:

fönster.öppna
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->nästa) { *huvud = curr;  /* Update next to prev node */ curr->next = prev;  lämna tillbaka;  } /* Spara curr->next node för rekursivt anrop */ Node* next = curr->next;  /* och uppdatera nästa ..*/ curr->next = prev;  reverseUtil(nästa, curr, huvud); } // En verktygsfunktion för att skriva ut en länkad lista void printlist(Node* head) { while (head != NULL) { cout<< head->data<< ' ';  head = head->Nästa;  } cout<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->nästa = ny Node(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->nästa) { *huvud = curr;  /* Update next to prev node */ curr->next = prev;  lämna tillbaka;  } /* Spara curr->next node för rekursivt anrop */ Node* next = curr->next;  /* och uppdatera nästa ..*/ curr->next = prev;  reverseUtil(nästa, curr, huvud); } // En verktygsfunktion för att skapa en ny nod Node* newNode(int-nyckel) { Node* temp = (Node*)malloc(sizeof(Node));  temp->data = nyckel;  temp->nästa = NULL;  returtemp; } // En verktygsfunktion för att skriva ut en länkad lista void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  huvud = huvud->nästa;  } printf('
'); } // Drivrutinskod 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('Given länkad lista
');  printlist(head1);  reverse(&head1);  printf('Omvänd länkad lista
');  printlist(head1);  returnera 0; } // Denna kod är bidragit av 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->nästa nod för rekursivt anrop */ Nod nästa1 = curr.next;  /* och uppdatera nästa ..*/ curr.next = prev;  reverseUtil(nästa1, curr);  returnera huvudet;  } // skriver ut innehållet i dubbellänkad lista void printList(Node node) { while (nod != null) { System.out.print(node.data + ' ');  nod = nod.next;  } } // Driver Code public static void main(String[] args) { LinkedList list = new LinkedList();  list.head = ny Node(1);  list.head.next = ny Node(2);  list.head.next.next = ny Node(3);  list.head.next.next.next = ny Node(4);  list.head.next.next.next.next = ny Node(5);  list.head.next.next.next.next.next = ny Node(6);  list.head.next.next.next.next.next.next = ny Node(7);  list.head.next.next.next.next.next.next.next = new Node(8);  System.out.println('Given länkad lista ');  list.printList(huvud);  Node res = list.reverseUtil(huvud, null);  System.out.println('
Omvänd länkad lista ');  list.printList(res);  } } // Denna kod är bidragit av Aditya Kumar (adityakumar129)>
Pytonorm 
# 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ästa nod för rekursivt anrop */ Nod nästa1 = curr.next;  /* och uppdatera nästa ..*/ curr.next = prev;  reverseUtil(nästa1, curr);  returnera huvudet;  } // skriver ut innehållet i dubbellänkad lista void printList(Node node) { while (nod != null) { Console.Write(node.data + ' ');  nod = nod.next;  } } // Driver code public static void Main(String[] args) { LinkedList list = new LinkedList();  list.head = ny Node(1);  list.head.next = ny Node(2);  list.head.next.next = ny Node(3);  list.head.next.next.next = ny Node(4);  list.head.next.next.next.next = ny Node(5);  list.head.next.next.next.next.next = ny Node(6);  list.head.next.next.next.next.next.next = ny Node(7);  list.head.next.next.next.next.next.next.next = new Node(8);  Console.WriteLine('Given länkad lista ');  list.printList(list.head);  Node res = list.reverseUtil(list.head, null);  Console.WriteLine('
Omvänd länkad lista ');  list.printList(res);  } } // Denna kod bidragit från Rajput-Ji>
Javascript 
>
Produktion 
Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1>

Tidskomplexitet: O(N), besöker varje nod i den länkade listan med storlek N.
Hjälputrymme: O(N), stackutrymme för funktionsanrop

Vänd om en länkad lista med Tanken är att lagra alla noder i stacken och sedan göra en omvänd länkad lista.

Följ stegen nedan för att lösa problemet:

  • Lagra noderna (värden och adress) i stacken tills alla värden är inmatade.
  • När alla inmatningar är klara uppdaterar du huvudpekaren till den sista platsen (dvs det sista värdet).
  • Börja poppa noderna (värde och adress) och lagra dem i samma ordning tills stacken är tom.
  • Uppdatera nästa pekare för sista nod i stacken med NULL.

Nedan är implementeringen av ovanstående tillvägagångssätt:

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;  Nod* temp = *huvud;  while (temp->next != NULL) { // Tryck in alla noder för att stacka s.push(temp);  temp = temp->nästa;  } *huvud = temp;  while (!s.empty()) { // Lagra det översta värdet av stack i list temp->next = s.top();  // Pop värdet från stack s.pop();  // uppdatera nästa pekare i listan temp = temp->nästa;  } temp->nästa = NULL; } // Funktion för att visa elementen i List void printlist(Node* temp) { while (temp != NULL) { cout<< temp->data<< ' ';  temp = temp->Nästa;  } } // Program för att infoga baksidan av den länkade listan void insert_back(Node** huvud, int värde) {// vi har använt metoden insertion at back för att skriva in värden // i listan.(t.ex.: head->1->2->3->4->Null) Nod* temp = ny Nod(värde);  temp->nästa = NULL;  // Om *huvud är lika med NULL if (*huvud == NULL) { *huvud = temp;  lämna tillbaka;  } annat { Node* last_node = *huvud;  while (last_node->next != NULL) last_node = last_node->next;  last_node->next = temp;  lämna tillbaka;  } } // Driver Code 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 = ny stack();  Nod temp = huvud;  while (temp.next != null) { // Tryck in alla noder för att stacka s.add(temp);  temp = temp.nästa;  } huvud = temp;  while (!s.isEmpty()) { // Lagra det översta värdet av stack i listan temp.next = s.peek();  // Pop värdet från stack s.pop();  // uppdatera nästa pekare i listan temp = temp.next;  } temp.next = null;  } // Funktion för att visa elementen i List static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.nästa;  } } // Program för att infoga baksidan av den länkade listan static void insert_back(int value) { // vi har använt insertion at back-metoden för att mata in //-värden i listan.(t.ex.: head.1.2.3.4.Null) Node temp = ny Node(värde);  temp.next = null;  // Om *huvud är lika med null if (huvud == null) { head = temp;  lämna tillbaka;  } else { Node last_node = huvud;  while (last_node.next != null) last_node = last_node.next;  last_node.next = temp;  lämna tillbaka;  } } // Driver Code public static void main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  System.out.print('Given länkad lista
');  printlist(huvud);  reverseLL();  System.out.print('
Omvänd länkad lista
');  printlist(huvud);  } } // Denna kod är bidragit av Aditya Kumar (adityakumar129)>
Pytonorm 
# 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 = Inget returhuvud # Driver Code if __name__ == '__main__': head = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print('Given länkad lista') temp = head while temp: print(temp.val, end=' ') temp = temp.next obj = Solution() print(' 
Omvänd länkad lista') head = obj.reverseLLUsingStack(head) medan 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 = ny stack();  Nod temp = huvud;  while (temp.next != null) { // Tryck in alla noder // för att stacka s.Push(temp);  temp = temp.nästa;  } huvud = temp;  while (s.Count != 0) { // Lagra det översta värdet av // stack i listan temp.next = s.Peek();  // Pop värdet från stack s.Pop();  // Uppdatera nästa pekare i // i listan temp = temp.next;  } temp.next = null;  } // Funktion för att visa // elementen i List static void printlist(Node temp) { while (temp != null) { Console.Write(temp.data + ' ');  temp = temp.nästa;  } } // Funktion för att infoga baksidan av den // länkade listan static void insert_back(int val) { // Vi har använt metoden insertion at back // för att ange värden i listan.(t.ex.: // head.1.2.3.4 .Null) Nod temp = new Node(val);  temp.next = null;  // Om *huvud är lika med null if (huvud == null) { head = temp;  lämna tillbaka;  } else { Node last_node = huvud;  while (last_node.next != null) { last_node = last_node.next;  } last_node.next = temp;  lämna tillbaka;  } } // Driver Code public static void Main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  Console.Write('Given länkad lista
');  printlist(huvud);  reverseLL();  Console.Write('
Omvänd länkad lista
');  printlist(huvud);  } } // Denna kod är bidragit från gauravrajput1>
Javascript 
>
Produktion 
Given linked list 1 2 3 4 Reversed linked list 4 3 2 1>

Tidskomplexitet: O(N), besöker varje nod i den länkade listan med storlek N.
Hjälputrymme: O(N), Space används för att lagra noderna i stacken.