INVERTIRE UN ELENCO COLLEGATO - TECHCODEVIEW.COM

Dato un puntatore al nodo principale di una lista concatenata, il compito è invertire la lista concatenata. Dobbiamo invertire l'elenco modificando i collegamenti tra i nodi.

Esempi :

Ingresso : Responsabile della seguente lista collegata
1->2->3->4->NULL
Produzione : L'elenco collegato dovrebbe essere modificato in,
4->3->2->1->NULL

Ingresso : Responsabile della seguente lista collegata
1->2->3->4->5->NULL
Produzione : L'elenco collegato dovrebbe essere modificato in,
5->4->3->2->1->NULL

Ingresso : NULLO
Produzione : NULLO

Ingresso : 1->NULL
Produzione : 1->NULL

Pratica consigliata Invertire un elenco collegato Provalo!

Invertire un elenco collegato tramite il metodo iterativo:

L'idea è di utilizzare tre puntatori corr , anteprima, E Prossimo per tenere traccia dei nodi per aggiornare i collegamenti inversi.

Seguire i passaggi seguenti per risolvere il problema:

Inizializza tre puntatori prec come NULL, corr COME Testa , E Prossimo come NULL.
Scorrere l'elenco collegato. In un ciclo, procedi come segue:
- Prima di cambiare il Prossimo Di corr , memorizzare il Prossimo nodo
  - successivo = corrente -> successivo
- Ora aggiorna il Prossimo puntatore di corr al prec
  - corrente -> successivo = prec
- Aggiornamento prec COME corr E corr COME Prossimo
  - prec. = corr
  - curr = successivo

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

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->dati = dati;  successivo = NULL;  } }; struct LinkedList { Nodo* testa;  Lista Collegata() { testa = NULL; } /* Funzione per invertire la lista concatenata */ void reverse() { // Inizializza i puntatori corrente, precedente e successivo Node* current = head;  Nodo *prev = NULL, *next = NULL;  while (current!= NULL) { // Memorizza next next = current->next;  // Inverte il puntatore del nodo corrente current->next = prev;  // Sposta i puntatori una posizione avanti.  precedente = corrente;  corrente = successivo;  } testa = precedente;  } /* Funzione per stampare la lista concatenata */ void print() { struct Node* temp = head;  while (temp!= NULL) { cout<< temp->dati<< ' ';  temp = temp->Prossimo;  } } void push(int dati) { Nodo* temp = nuovo Nodo(dati);  temp->successivo = testa;  testa = temperatura;  } }; /* Codice driver*/ int main() { /* Inizia con l'elenco vuoto */ 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; }>

 // 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->Prossimo;  // Inverte il puntatore del nodo corrente current->next = prev;  // Sposta i puntatori una posizione avanti.  precedente = corrente;  corrente = successivo;  } *head_ref = prev; } /* Funzione per spingere un nodo */ void push(struct Node** head_ref, int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));  nuovo_nodo->dati = nuovi_dati;  nuovo_nodo->successivo = (*head_ref);  (*head_ref) = nuovo_nodo; } /* Funzione per stampare la lista concatenata */ void printList(struct Node* head) { struct Node* temp = head;  while (temp != NULL) { printf('%d ', temp->data);  temp = temp->successivo;  } } /* Codice driver*/ int main() { /* Inizia con l'elenco vuoto */ struct Node* head = NULL;  spingere(&testa, 20);  spingi(&testa, 4);  spingere(&testa, 15);  spingere(&testa, 85);  printf('Elenco collegato fornito
');  stampaLista(testa);  inverso(&testa);  printf('
Elenco collegato invertito
');  stampaLista(testa);  getchar(); }>

Giava

 // 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>

Pitone

 # 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# 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

Produzione

Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Complessità temporale: O(N), attraversamento dell'elenco concatenato di dimensione N.
Spazio ausiliario: O(1)

Invertire un elenco collegato utilizzando la ricorsione:

L'idea è di raggiungere l'ultimo nodo dell'elenco collegato utilizzando la ricorsione, quindi iniziare a invertire l'elenco collegato.

Seguire i passaggi seguenti per risolvere il problema:

Dividi l'elenco in due parti: primo nodo e resto dell'elenco collegato.
Chiama inverso per il resto dell'elenco collegato.
Collega prima il resto dell'elenco collegato.
Correggi il puntatore della testa su NULL

Di seguito è riportata l'implementazione dell'approccio di cui sopra:

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->dati = dati;  successivo = NULL;  } }; struct LinkedList { Nodo* testa;  Lista Collegata() { testa = NULL; } Node* reverse(Node* head) /* Funzione per stampare la lista concatenata */ void print() { struct Node* temp = head;  while (temp!= NULL) { cout<< temp->dati<< ' ';  temp = temp->Prossimo;  } } void push(int dati) { Nodo* temp = nuovo Nodo(dati);  temp->successivo = testa;  testa = temperatura;  } }; /* Programma driver per testare la funzione sopra*/ int main() { /* Inizia con l'elenco vuoto */ 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; }>

Giava

 // 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>

Pitone

 '''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>

 // 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

Produzione

Given linked list 85 15 4 20 Reversed linked list 20 4 15 85>

Complessità temporale: O(N), Visita su ogni nodo una volta
Spazio ausiliario: O(N), spazio dello stack delle chiamate di funzione

Invertire un elenco collegato con il metodo ricorsivo della coda:

L'idea è di mantenere tre puntatori precedente , attuale E Prossimo , visita ricorsivamente ogni nodo e crea collegamenti utilizzando questi tre puntatori.

Seguire i passaggi seguenti per risolvere il problema:

Primo aggiornamento successivo con il nodo successivo della corrente, ad es. successivo = corrente->successivo
Ora crea un collegamento inverso dal nodo corrente al nodo precedente, ovvero curr->next = prev
Se il nodo visitato è l'ultimo nodo, basta creare un collegamento inverso dal nodo corrente al nodo precedente e aggiornare head.

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

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->successivo) { *testa = curr;  /* Aggiorna accanto al nodo precedente */ curr->next = prev;  ritorno;  } /* Salva il nodo curr->next per la chiamata ricorsiva */ Node* next = curr->next;  /* e aggiorna next ..*/ curr->next = prev;  reverseUtil(successivo, curr, testa); } // Una funzione di utilità per stampare una lista concatenata void printlist(Node* head) { while (head != NULL) { cout<< head->dati<< ' ';  head = head->Prossimo;  } cout<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->successivo = nuovo nodo(2);  head1->successivo->successivo = nuovo nodo(3);  head1->successivo->successivo->successivo = nuovo nodo(4);  head1->successivo->successivo->successivo->successivo = nuovo nodo(5);  head1->successivo->successivo->successivo->successivo->successivo = nuovo Nodo(6);  head1->successivo->successivo->successivo->successivo->successivo->successivo = nuovo Nodo(7);  head1->successivo->successivo->successivo->successivo->successivo->successivo->successivo = nuovo Nodo(8);  cout<< 'Given linked list
';  printlist(head1);  reverse(&head1);  cout << 'Reversed linked list
';  printlist(head1);  return 0; }>

 // 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->successivo) { *testa = curr;  /* Aggiorna accanto al nodo precedente */ curr->next = prev;  ritorno;  } /* Salva il nodo curr->next per la chiamata ricorsiva */ Node* next = curr->next;  /* e aggiorna next ..*/ curr->next = prev;  reverseUtil(successivo, curr, testa); } // Una funzione di utilità per creare un nuovo nodo Node* newNode(int key) { Node* temp = (Node*)malloc(sizeof(Node));  temp->dati = chiave;  temp->successivo = NULL;  temperatura di ritorno; } // Una funzione di utilità per stampare un elenco collegato void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  testa = testa->successivo;  } printf('
'); } // Codice driver int main() { Node* head1 = newNode(1);  testa1->successivo = nuovoNodo(2);  head1->successivo->successivo = nuovoNodo(3);  head1->successivo->successivo->successivo = nuovoNodo(4);  head1->successivo->successivo->successivo->successivo = nuovoNodo(5);  head1->successivo->successivo->successivo->successivo->successivo = nuovoNodo(6);  head1->successivo->successivo->successivo->successivo->successivo->successivo = nuovoNodo(7);  head1->successivo->successivo->successivo->successivo->successivo->successivo->successivo = newNode(8);  printf('Elenco collegato fornito
');  printlist(testa1);  inverso(&testa1);  printf('Elenco collegato invertito
');  printlist(testa1);  restituire 0; } // Questo codice è un contributo di Aditya Kumar (adityakumar129)>

Giava

 // 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->nodo successivo per chiamata ricorsiva */ Nodo next1 = curr.next;  /* e aggiorna il prossimo ..*/ curr.next = prev;  reverseUtil(successivo1, corrente);  testa di ritorno;  } // stampa il contenuto della doppia lista concatenata void printList(Node node) { while (node != null) { System.out.print(node.data + ' ');  nodo = nodo.successivo;  } } // Codice driver public static void main(String[] args) { LinkedList list = new LinkedList();  list.head = nuovo nodo(1);  list.head.next = nuovo nodo(2);  list.head.next.next = nuovo nodo(3);  list.head.next.next.next = nuovo nodo(4);  list.head.next.next.next.next = nuovo nodo(5);  list.head.next.next.next.next.next = nuovo nodo(6);  list.head.next.next.next.next.next.next = nuovo nodo(7);  list.head.next.next.next.next.next.next.next = nuovo nodo(8);  System.out.println('Elenco collegato fornito ');  lista.printLista(testa);  Nodo res = list.reverseUtil(head, null);  System.out.println('
Elenco collegato invertito ');  lista.printLista(res);  } } // Questo codice è un contributo di Aditya Kumar (adityakumar129)>

Pitone

 # 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# 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->nodo successivo per chiamata ricorsiva */ Nodo next1 = curr.next;  /* e aggiorna il prossimo ..*/ curr.next = prev;  reverseUtil(successivo1, corrente);  testa di ritorno;  } // stampa il contenuto della lista con doppio collegamento void printList(Node node) { while (node != null) { Console.Write(node.data + ' ');  nodo = nodo.successivo;  } } // Codice driver public static void Main(String[] args) { LinkedList list = new LinkedList();  list.head = nuovo nodo(1);  list.head.next = nuovo nodo(2);  list.head.next.next = nuovo nodo(3);  list.head.next.next.next = nuovo nodo(4);  list.head.next.next.next.next = nuovo nodo(5);  list.head.next.next.next.next.next = nuovo nodo(6);  list.head.next.next.next.next.next.next = nuovo nodo(7);  list.head.next.next.next.next.next.next.next = nuovo nodo(8);  Console.WriteLine('Elenco collegato fornito ');  lista.printLista(lista.head);  Nodo res = list.reverseUtil(list.head, null);  Console.WriteLine('
Elenco collegato invertito ');  lista.printLista(res);  } } // Questo codice è stato fornito da Rajput-Ji>

Javascript

Produzione

Given linked list 1 2 3 4 5 6 7 8 Reversed linked list 8 7 6 5 4 3 2 1>

Complessità temporale: O(N), Visitando ogni nodo della lista concatenata di dimensione N.
Spazio ausiliario: O(N), spazio dello stack delle chiamate di funzione

Invertire un elenco collegato utilizzando L'idea è di memorizzare tutti i nodi nello stack e quindi creare un elenco con collegamenti inversi.

Seguire i passaggi seguenti per risolvere il problema:

Memorizza i nodi (valori e indirizzo) nello stack finché non vengono immessi tutti i valori.
Una volta completate tutte le voci, aggiorna il puntatore Head all'ultima posizione (ovvero l'ultimo valore).
Inizia a estrarre i nodi (valore e indirizzo) e memorizzali nello stesso ordine finché lo stack non è vuoto.
Aggiorna il puntatore successivo dell'ultimo nodo nello stack con NULL.

Di seguito è riportata l’implementazione dell’approccio di cui sopra:

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;  Nodo* temp = *testa;  while (temp->next != NULL) { // Spingi tutti i nodi per impilarli s.push(temp);  temp = temp->successivo;  } *testa = temperatura;  while (!s.empty()) { // Memorizza il valore più alto dello stack nella lista temp->next = s.top();  // Estrae il valore dallo stack s.pop();  // aggiorna il puntatore successivo nell'elenco temp = temp->next;  } temp->successivo = NULL; } // Funzione per visualizzare gli elementi nella lista void printlist(Node* temp) { while (temp != NULL) { cout<< temp->dati<< ' ';  temp = temp->Prossimo;  } } // Programma per inserire il retro della lista concatenata void insert_back(Node** head, int value) { // abbiamo utilizzato il metodo di inserimento sul retro per inserire valori // nella lista.(es: head->1->2->3->4->Null) Nodo* temp = nuovo Nodo(valore);  temp->successivo = NULL;  // Se *head è uguale a NULL if (*head == NULL) { *head = temp;  ritorno;  } else { Nodo* ultimo_nodo = *testa;  while (ultimo_nodo->successivo!= NULL) ultimo_nodo = ultimo_nodo->successivo;  ultimo_nodo->successivo = temp;  ritorno;  } } // Codice driver int main() { Node* head = NULL;  insert_back(&testa, 1);  insert_back(&testa, 2);  insert_back(&testa, 3);  insert_back(&testa, 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)>

Giava

 // 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 = nuova pila();  Temp. nodo = testa;  while (temp.next!= null) { // Inserisci tutti i nodi nello stack s.add(temp);  temp = temp.successiva;  } testa = temperatura;  while (!s.isEmpty()) { // Memorizza il valore più alto dello stack nella lista temp.next = s.peek();  // Estrae il valore dallo stack s.pop();  // aggiorna il puntatore successivo nell'elenco temp = temp.next;  } temp.successivo = null;  } // Funzione per visualizzare gli elementi nella lista static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.successiva;  } } // Programma per inserire il retro della lista concatenata static void insert_back(int value) { // abbiamo usato il metodo di inserimento sul retro per inserire // valori nella lista.(es: head.1.2.3.4.Null) Node temp = nuovo nodo(valore);  temp.successivo = nullo;  // Se *testa è uguale a null if (testa == null) { testa = temp;  ritorno;  } else { Nodo ultimo_nodo = testa;  while (ultimo_nodo.successivo!= null) ultimo_nodo = ultimo_nodo.successivo;  ultimo_nodo.next = temp;  ritorno;  } } // Codice driver public static void main(String[] args) { insert_back(1);  inserisci_indietro(2);  inserisci_indietro(3);  inserisci_indietro(4);  System.out.print('Elenco collegato fornito
');  lista di stampa(testa);  reverseLL();  System.out.print('
Elenco collegato invertito
');  lista di stampa(testa);  } } // Questo codice è un contributo di Aditya Kumar (adityakumar129)>

Pitone

 # 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 = Nessuno return head # Codice driver if __name__ == '__main__': head = ListNode(1, ListNode(2, ListNode(3, ListNode(4)))) print('Data lista concatenata') temp = head while temp: print(temp.val, end=' ') temp = temp.next obj = Solution() print(' 
Elenco concatenato invertito') head = obj.reverseLLUsingStack(head) while head: print(head.val, end=' ') head = head.next>

 // 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 = nuova pila();  Temp. nodo = testa;  while (temp.next != null) { // Spingi tutti i nodi // nello stack s.Push(temp);  temp = temp.successiva;  } testa = temperatura;  while (s.Count != 0) { // Memorizza il valore più alto dello // stack nell'elenco temp.next = s.Peek();  // Estrae il valore dallo stack s.Pop();  // Aggiorna il puntatore successivo nella // lista temp = temp.next;  } temp.successivo = null;  } // Funzione per visualizzare // gli elementi nella Lista static void printlist(Node temp) { while (temp != null) { Console.Write(temp.data + ' ');  temp = temp.successiva;  } } // Funzione per inserire il retro della // lista concatenata static void insert_back(int val) { // Abbiamo utilizzato il metodo di inserimento sul retro // per inserire valori nella lista.(eg: // head.1.2.3.4 .Null) Temp. nodo = nuovo Nodo(val);  temp.successivo = nullo;  // Se *testa è uguale a null if (testa == null) { testa = temp;  ritorno;  } else { Nodo ultimo_nodo = testa;  while (ultimo_nodo.successivo!= null) { ultimo_nodo = ultimo_nodo.successivo;  } ultimo_nodo.next = temp;  ritorno;  } } // Codice driver public static void Main(String[] args) { insert_back(1);  inserisci_indietro(2);  inserisci_indietro(3);  inserisci_indietro(4);  Console.Write('Elenco collegato fornito
');  lista di stampa(testa);  reverseLL();  Console.Write('
Elenco collegato invertito
');  lista di stampa(testa);  } } // Questo codice è fornito da gauravrajput1>

Javascript

Produzione

Given linked list 1 2 3 4 Reversed linked list 4 3 2 1>

Complessità temporale: O(N), Visitando ogni nodo della lista concatenata di dimensione N.
Spazio ausiliario: O(N), lo spazio viene utilizzato per memorizzare i nodi nello stack.