logo

TechCodeview

Obrnite povezani seznam

Če imamo kazalec na glavno vozlišče povezanega seznama, je naloga obrniti povezani seznam. Seznam moramo obrniti tako, da spremenimo povezave med vozlišči.

nastavitve internetnega brskalnika

Primeri :



Vnos : Vodja naslednjega povezanega seznama
1->2->3->4->NULL
Izhod : Povezani seznam je treba spremeniti v,
4->3->2->1->NULL

Vnos : Vodja naslednjega povezanega seznama
1->2->3->4->5->NULL
Izhod : Povezani seznam je treba spremeniti v,
5->4->3->2->1->NULL

Vnos : NIČ
Izhod : NIČ



Vnos : 1->NULL
Izhod : 1->NULL

Priporočena praksa Obrnite povezan seznam Poskusite!

Obrnite povezani seznam z iterativno metodo:

Ideja je uporaba treh kazalcev curr , prejšnji, in Naslednji za spremljanje vozlišč za posodobitev povratnih povezav.

Za rešitev težave sledite spodnjim korakom:



  • Inicializirajte tri kazalce prev kot NULL, curr kot glavo , in Naslednji kot NULL.
  • Ponavljajte po povezanem seznamu. V zanki naredite naslednje:
    • Preden spremenite Naslednji od curr , shranite Naslednji vozlišče
      • naslednji = curr -> naslednji
    • Zdaj posodobite Naslednji kazalec na curr do prev
      • curr -> next = prev
    • Nadgradnja prev kot curr in curr kot Naslednji
      • prev = curr
      • curr = naslednji

Spodaj je izvedba zgornjega pristopa:

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->podatki = podatki;  naslednji = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { glava = NULL; } /* Funkcija za obračanje povezanega seznama */ void reverse() { // Inicializira trenutne, prejšnje in naslednje kazalce Vozlišče* current = head;  Vozlišče *prev = NULL, *naslednje = NULL;  medtem ko (trenutno != NULL) { // Shrani naslednji naslednji = trenutni->naslednji;  // Obrni kazalec trenutnega vozlišča current->next = prev;  // Premakni kazalce eno mesto naprej.  prejšnji = trenutni;  trenutno = naslednji;  } glava = prejšnja;  } /* Funkcija za tiskanje povezanega seznama */ void print() { struct Node* temp = head;  medtem ko (temp != NULL) { cout<< temp->podatke<< ' ';  temp = temp->Naslednji;  } } void push(int data) { Node* temp = new Node(data);  temp->naprej = glava;  glava = temp;  } }; /* Koda gonilnika*/ int main() { /* Začni s praznim seznamom */ 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->Naslednji;  // Obrne kazalec trenutnega vozlišča current->next = prev;  // Premakni kazalce eno mesto naprej.  prejšnji = trenutni;  trenutno = naslednji;  } *head_ref = prejšnji; } /* Funkcija za potiskanje vozlišča */ void push(struct Node** head_ref, int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));  novo_vozlišče->podatki = novi_podatki;  novo_vozlišče->naslednji = (*head_ref);  (*head_ref) = novo_vozlišče; } /* Funkcija za tiskanje povezanega seznama */ void printList(struct Node* head) { struct Node* temp = head;  medtem ko (temp != NULL) { printf('%d ', temp->data);  temp = temp->naprej;  } } /* Koda gonilnika*/ int main() { /* Začni s praznim seznamom */ struct Node* head = NULL;  potisni(&glava, 20);  potisni(&glava, 4);  potisni(&glava, 15);  potisni(&glava, 85);  printf('Dani povezani seznam
');  printList(head);  vzvratno(&glava);  printf('
Obrnjen povezan seznam 
');  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 
>
Izhod 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Časovna zapletenost: O(N), premik čez povezani seznam velikosti N.
Pomožni prostor: O(1)

java vzorčni programi

Obrnite povezani seznam z uporabo rekurzije:

Ideja je doseči zadnje vozlišče povezanega seznama z uporabo rekurzije in nato začeti obračati povezani seznam.

Za rešitev težave sledite spodnjim korakom:

  • Seznam razdelite na dva dela – prvo vozlišče in preostali del povezanega seznama.
  • Pokličite obratno za preostali del povezanega seznama.
  • Prvo povežite preostali povezani seznam.
  • Popravi kazalec glave na NULL

Spodaj je izvedba zgornjega pristopa:

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->podatki = podatki;  naslednji = NULL;  } }; struct LinkedList { Node* head;  LinkedList() { glava = NULL; } Node* reverse(Node* head) /* Funkcija za tiskanje povezanega seznama */ void print() { struct Node* temp = head;  medtem ko (temp != NULL) { cout<< temp->podatke<< ' ';  temp = temp->Naslednji;  } } void push(int data) { Node* temp = new Node(data);  temp->naprej = glava;  glava = temp;  } }; /* Program gonilnika za preizkus zgornje funkcije*/ int main() { /* Začni s praznim seznamom */ 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 
>
Izhod 
Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Časovna zapletenost: O(N), Enkraten obisk vsakega vozlišča
Pomožni prostor: O(N), prostor sklada klicev funkcij

nastavi v javi

Obrnite povezani seznam z repno rekurzivno metodo:

Ideja je ohraniti tri točke prejšnji , trenutno in Naslednji , rekurzivno obiščete vsako vozlišče in ustvarite povezave z uporabo teh treh kazalcev.

Za rešitev težave sledite spodnjim korakom:

  • Prva posodobitev naslednja z naslednjim vozliščem trenutnega i.e. naslednji = trenutno->naslednji
  • Zdaj naredite povratno povezavo od trenutnega vozlišča do prejšnjega vozlišča, tj. curr->next = prev
  • Če je obiskano vozlišče zadnje vozlišče, naredite vzvratno povezavo od trenutnega vozlišča do prejšnjega vozlišča in posodobite glavo.

Spodaj je izvedba zgornjega pristopa:

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->naslednji) { *head = curr;  /* Posodobi poleg prejšnjega vozlišča */ curr->next = prev;  vrnitev;  } /* Shrani vozlišče curr->next za rekurziven klic */ Node* next = curr->next;  /* in posodobi naslednje ..*/ curr->next = prev;  reverseUtil(naslednji, curr, glava); } // Pomožna funkcija za tiskanje povezanega seznama void printlist(Node* head) { while (head != NULL) { cout<< head->podatke<< ' ';  head = head->Naslednji;  } cout<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->naslednji = novo vozlišče (2);  glava1->naslednji->naslednji = novo vozlišče(3);  glava1->naslednji->naslednji->naslednji = novo vozlišče(4);  glava1->naslednji->naslednji->naslednji->naslednji = novo vozlišče(5);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji = novo vozlišče(6);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji = novo vozlišče(7);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji = novo vozlišče(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->naslednji) { *head = curr;  /* Posodobi poleg prejšnjega vozlišča */ curr->next = prev;  vrnitev;  } /* Shrani vozlišče curr->next za rekurziven klic */ Node* next = curr->next;  /* in posodobi naslednje ..*/ curr->next = prev;  reverseUtil(naslednji, curr, glava); } // Pomožna funkcija za ustvarjanje novega vozlišča Node* newNode(int key) { Node* temp = (Node*)malloc(sizeof(Node));  temp->podatki = ključ;  temp->naslednji = NULL;  povratna temperatura; } // Pomožna funkcija za tiskanje povezanega seznama void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  glava = glava->naprej;  } printf('
'); } // Koda gonilnika int main() { Node* head1 = newNode(1);  glava1->naslednji = novoVozlišče(2);  glava1->naslednji->naslednji = novoVozlišče(3);  glava1->naslednji->naslednji->naslednji = novoVozlišče(4);  glava1->naslednji->naslednji->naslednji->naslednji = novoVozlišče(5);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji = newNode(6);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji = newNode(7);  glava1->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji->naslednji = newNode(8);  printf('Dani povezani seznam
');  seznam za tiskanje (glava1);  vzvratno(&glava1);  printf('Obrnjen povezan seznam
');  seznam za tiskanje (glava1);  vrni 0; } // To kodo je prispeval 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->naslednje vozlišče za rekurzivni klic */ Vozlišče next1 = curr.next;  /* in posodobi naslednje ..*/ curr.next = prev;  reverseUtil(naslednji1, curr);  povratna glava;  } // natisne vsebino dvojno povezanega seznama void printList(Node node) { while (node ​​!= null) { System.out.print(node.data + ' ');  vozlišče = vozlišče.naslednji;  } } // Koda gonilnika public static void main(String[] args) { LinkedList list = new LinkedList();  list.head = novo vozlišče (1);  list.head.next = novo vozlišče (2);  list.head.next.next = novo vozlišče(3);  list.head.next.next.next = novo vozlišče(4);  list.head.next.next.next.next = novo vozlišče(5);  list.head.next.next.next.next.next = novo vozlišče(6);  list.head.next.next.next.next.next.next = novo vozlišče(7);  list.head.next.next.next.next.next.next.next = novo vozlišče(8);  System.out.println('Dani povezani seznam ');  list.printList(head);  Vozlišče res = list.reverseUtil(head, null);  System.out.println('
Obrnjen povezan seznam ');  list.printList(res);  } } // To kodo je prispeval 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->naslednje vozlišče za rekurzivni klic */ Vozlišče next1 = curr.next;  /* in posodobi naslednje ..*/ curr.next = prev;  reverseUtil(naslednji1, curr);  povratna glava;  } // natisne vsebino dvojno povezanega seznama void printList(Node node) { while (node ​​!= null) { Console.Write(node.data + ' ');  vozlišče = vozlišče.naslednji;  } } // Koda gonilnika public static void Main(String[] args) { LinkedList list = new LinkedList();  list.head = novo vozlišče (1);  list.head.next = novo vozlišče (2);  list.head.next.next = novo vozlišče (3);  list.head.next.next.next = novo vozlišče(4);  list.head.next.next.next.next = novo vozlišče(5);  list.head.next.next.next.next.next = novo vozlišče(6);  list.head.next.next.next.next.next.next = novo vozlišče(7);  list.head.next.next.next.next.next.next.next = novo vozlišče(8);  Console.WriteLine('Dani povezani seznam ');  list.printList(list.head);  Vozlišče res = list.reverseUtil(list.head, null);  Console.WriteLine('
Obrnjen povezan seznam ');  list.printList(res);  } } // To kodo je prispeval Rajput-Ji>
Javascript 
>
Izhod 
Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1>

Časovna zapletenost: O(N), obisk vsakega vozlišča povezanega seznama velikosti N.
Pomožni prostor: O(N), prostor sklada klicev funkcij

Obrnite povezani seznam z uporabo Ideja je shraniti vsa vozlišča v skladu in nato narediti povratno povezan seznam.

Za rešitev težave sledite spodnjim korakom:

  • Shranjujte vozlišča (vrednosti in naslov) v skladu, dokler niso vnesene vse vrednosti.
  • Ko so vsi vnosi končani, posodobite kazalec glave na zadnjo lokacijo (tj. zadnjo vrednost).
  • Začnite izločati vozlišča (vrednost in naslov) in jih shranjujte v enakem vrstnem redu, dokler sklad ni prazen.
  • Posodobite naslednji kazalec zadnjega vozlišča v skladu z NULL.

Spodaj je izvedba zgornjega pristopa:

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;  Vozlišče* temp = *glava;  while (temp->next != NULL) { // Potisnite vsa vozlišča v sklad s.push(temp);  temp = temp->naprej;  } *glava = temp;  while (!s.empty()) { // Shrani najvišjo vrednost sklada na seznam temp->next = s.top();  // Izstreli vrednost iz sklada s.pop();  // posodobi naslednji kazalec na seznamu temp = temp->next;  } temp->naslednji = NULL; } // Funkcija za prikaz elementov v seznamu void printlist(Node* temp) { while (temp != NULL) { cout<< temp->podatke<< ' ';  temp = temp->Naslednji;  } } // Program za vstavljanje nazaj na povezan seznam void insert_back(Node** head, int value) { // uporabili smo metodo vstavljanja nazaj za vnos vrednosti // na seznam. (npr.: glava->1->2->3->4->Null) Vozlišče* temp = novo vozlišče(vrednost);  temp->naslednji = NULL;  // Če je *head enak NULL if (*head == NULL) { *head = temp;  vrnitev;  } else { Vozlišče* zadnje_vozlišče = *glava;  medtem ko (zadnje_vozlišče->naslednje != NULL) zadnje_vozlišče = zadnje_vozlišče->naslednje;  zadnje_vozlišče->naslednje = začasno;  vrnitev;  } } // Koda gonilnika int main() { Node* head = NULL;  vstavi_nazaj(&glava, 1);  vstavi_nazaj(&glava, 2);  vstavi_nazaj(&glava, 3);  vstavi_nazaj(&glava, 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 = nov sklad();  Temperatura vozlišča = glava;  while (temp.next != null) { // Potisnite vsa vozlišča v sklad s.add(temp);  temp = temp.next;  } glava = temp;  while (!s.isEmpty()) { // Shrani zgornjo vrednost sklada na seznam temp.next = s.peek();  // Izstreli vrednost iz sklada s.pop();  // posodobi naslednji kazalec na seznamu temp = temp.next;  } temp.next = null;  } // Funkcija za prikaz elementov na seznamu static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.next;  } } // Program za vstavljanje nazaj na povezani seznam static void insert_back(int value) { // uporabili smo metodo vstavljanja nazaj za vnos // vrednosti na seznam. (npr.: head.1.2.3.4.Null) Vozlišče temp = novo vozlišče (vrednost);  temp.next = nič;  // Če je *head enak nič if (head == null) { head = temp;  vrnitev;  } else { Vozlišče zadnje_vozlišče = glava;  medtem ko (last_node.next != null) zadnje_node = last_node.next;  last_node.next = temp;  vrnitev;  } } // Koda gonilnika public static void main(String[] args) { insert_back(1);  vstavi_nazaj(2);  vstavi_nazaj(3);  vstavi_nazaj(4);  System.out.print('Dani povezani seznam
');  seznam za tiskanje (glava);  obratnoLL();  System.out.print('
Obrnjen povezan seznam
');  seznam za tiskanje (glava);  } } // To kodo je prispeval 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 = None return head # Koda gonilnika if __name__ == '__main__': head = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print('Dani povezani seznam') temp = head while temp: print(temp.val, end=' ') temp = temp.next obj = Solution() print(' 
Obrnjen povezan seznam') 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 = nov sklad();  Temperatura vozlišča = glava;  while (temp.next != null) { // Potisnite vsa vozlišča // v sklad s.Push(temp);  temp = temp.next;  } glava = temp;  while (s.Count != 0) { // Shrani zgornjo vrednost // sklada na seznamu temp.next = s.Peek();  // Izloči vrednost iz sklada s.Pop();  // Posodobi naslednji kazalec na // na seznamu temp = temp.next;  } temp.next = null;  } // Funkcija za prikaz // elementov na seznamu static void printlist(Node temp) { while (temp != null) { Console.Write(temp.data + ' ');  temp = temp.next;  } } // Funkcija za vstavljanje nazaj // povezanega seznama static void insert_back(int val) { // Uporabili smo metodo vstavljanja nazaj // za vnos vrednosti na seznam. (npr.: // glava.1.2.3.4 .Null) Temp vozlišča = novo vozlišče(val);  temp.next = nič;  // Če je *head enak nič if (head == null) { head = temp;  vrnitev;  } else { Vozlišče zadnje_vozlišče = glava;  medtem ko (zadnje_vozlišče.naslednje != null) { zadnje_vozlišče = zadnje_vozlišče.naslednje;  } zadnje_vozlišče.naslednje = začasno;  vrnitev;  } } // Koda gonilnika public static void Main(String[] args) { insert_back(1);  vstavi_nazaj(2);  vstavi_nazaj(3);  vstavi_nazaj(4);  Console.Write('Dani povezani seznam
');  seznam za tiskanje (glava);  obratnoLL();  Console.Write('
Obrnjen povezan seznam
');  seznam za tiskanje (glava);  } } // To kodo je prispeval gauravrajput1>
Javascript 
>
Izhod 
Given linked list 1 2 3 4 Reversed linked list 4 3 2 1>

Časovna zapletenost: O(N), obisk vsakega vozlišča povezanega seznama velikosti N.
Pomožni prostor: O(N), prostor se uporablja za shranjevanje vozlišč v skladu.