// 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->date = date;  următorul = NULL;  } }; struct LinkedList { Node* cap;  LinkedList() { head = NULL; } /* Funcție de inversare a listei legate */ void reverse() { // Inițializează pointerii curenti, anteriori și următori Node* curent = cap;  Nodul *prev = NULL, *next = NULL;  while (current != NULL) { // Store next next = curent->next;  // Inversa indicatorul nodului curent curent->next = prev;  // Mută ​​pointerii cu o poziție înainte.  prev = curent;  curent = următorul;  } cap = prev;  } /* Funcție de tipărire a listei legate */ void print() { struct Node* temp = head;  while (temp != NULL) { cout<< temp->date<< ' ';  temp = temp->Următorul;  } } void push(int data) { Node* temp = new Node(date);  temp->next = cap;  cap = temp;  } }; /* Cod driver*/ int main() { /* Începe cu lista goală */ 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->Următorul;  // Inversa indicatorul nodului curent curent->next = prev;  // Mută ​​pointerii cu o poziție înainte.  prev = curent;  curent = următorul;  } *head_ref = prev; } /* Funcție de împingere a unui 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;  nou_nod->next = (*head_ref);  (*head_ref) = new_node; } /* Funcție de tipărire a listei legate */ void printList(struct Node* head) { struct Node* temp = head;  while (temp != NULL) { printf('%d ', temp->data);  temp = temp->next;  } } /* Cod driver*/ int main() { /* Începe cu lista goală */ struct Node* head = NULL;  împinge(&cap, 20);  împinge(&cap, 4);  împinge(&cap, 15);  împinge(&cap, 85);  printf('Dată lista legată
');  printList(cap);  invers (&cap);  printf('
Lista legată inversată 
');  printList(cap);  getchar(); }>>>Java

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

>>>  
  Ieșire      Complexitatea timpului:    O(N), parcurgerea listei legate de mărimea N.  
    Spațiu auxiliar:    O(1)
 
    Inversați o listă conectată folosind recursiunea:    
 
Ideea este să ajungeți la ultimul nod al listei legate folosind recursiunea, apoi începeți să inversați lista legată.
 
tabelul ASCII în c
 
Urmați pașii de mai jos pentru a rezolva problema:
 
Împărțiți lista în două părți - primul nod și restul listei legate.
Apelați invers pentru restul listei conectate.
Conectează restul listei conectate la prima.
Fixați indicatorul de cap la NULL
Mai jos este implementarea abordării de mai sus:
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->date = date;  următorul = NULL;  } }; struct LinkedList { Node* cap;  LinkedList() { head = NULL; } Nod* reverse(Nod* head) /* Funcție pentru a tipări lista legată */ void print() { struct Node* temp = cap;  while (temp != NULL) { cout<< temp->date<< ' ';  temp = temp->Următorul;  } } void push(int data) { Node* temp = new Node(date);  temp->next = cap;  cap = temp;  } }; /* Program driver de testat mai sus*/ int main() { /* Începe cu lista goală */ 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>
 Piton 
'''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 
>>>  
  Ieșire      Complexitatea timpului:    O(N), Vizitarea fiecărui nod o dată          
    Spațiu auxiliar:    O(N), spațiu pentru stiva de apeluri de funcție
 
    Inversați o listă legată prin metoda recursive de coadă:    
 
Ideea este de a menține trei puncte    anterior    ,    actual    și    Următorul    , vizitați recursiv fiecare nod și faceți legături folosind acești trei pointeri.
js settimeout
 
Urmați pașii de mai jos pentru a rezolva problema:
 
Urmează prima actualizare cu următorul nod al curentului, adică    următorul = curent->următorul    
Acum faceți o legătură inversă de la nodul curent la nodul anterior, adică curr->next = prev
Dacă nodul vizitat este ultimul nod, faceți doar o legătură inversă de la nodul curent la nodul anterior și actualizați capul.
Mai jos este implementarea abordării de mai sus:
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->următorul) { *head = curr;  /* Actualizare lângă nodul anterior */ curr->next = prev;  întoarcere;  } /* Salvare curr->next node pentru apel recursiv */ Node* next = curr->next;  /* și actualizați următorul ..*/ curr->next = prev;  reverseUtil(next, curr, head); } // O funcție de utilitate pentru a tipări o listă legată void printlist(Node* head) { while (head != NULL) { cout<< head->date<< ' ';  head = head->Următorul;  } cout<< endl; } // Driver code int main() {  Node* head1 = new Node(1);  head1->următorul = nou Nod(2);  head1->next->next = nou Nod(3);  head1->next->next->next = nou Nod(4);  head1->next->next->next->next = Nod nou(5);  head1->next->next->next->next->next = nou Nod(6);  head1->next->next->next->next->next->next = nou Nod(7);  head1->next->next->next->next->next->next->next = nou Nod(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->următorul) { *head = curr;  /* Actualizare lângă nodul anterior */ curr->next = prev;  întoarcere;  } /* Salvare curr->next node pentru apel recursiv */ Node* next = curr->next;  /* și actualizați următorul ..*/ curr->next = prev;  reverseUtil(next, curr, head); } // O funcție de utilitate pentru a crea un nou nod Node* newNode(int key) { Node* temp = (Node*)malloc(sizeof(Node));  temp->data = cheie;  temp->next = NULL;  temperatura de retur; } // O funcție utilitar pentru a tipări o listă legată void printlist(Node* head) { while (head != NULL) { printf('%d ', head->data);  cap = cap->next;  } printf('
'); } // Cod driver int main() { Nod* 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('Dată lista legată
');  printlist(head1);  invers (&head1);  printf('Lista legată inversată
');  printlist(head1);  întoarce 0; } // Acest cod este contribuit de Aditya Kumar (adityakumar129)>>Java>Piton
 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->nodul următor pentru apel recursiv */ Nodul următor1 = curr.next;  /* și actualizați următorul ..*/ curr.next = prev;  reverseUtil(next1, curr);  cap de întoarcere;  } // afișează conținutul listei duble legate void printList(Node node) { while (node ​​!= null) { Console.Write(node.data + ' ');  nod = nod.next;  } } // Cod driver public static void Main(String[] args) { Lista LinkedList = new LinkedList();  list.head = nou Nod(1);  list.head.next = Nod nou (2);  list.head.next.next = Nod nou (3);  list.head.next.next.next = Nod nou (4);  list.head.next.next.next.next = Nod nou (5);  list.head.next.next.next.next.next.next = Nod nou (6);  list.head.next.next.next.next.next.next.next = Nod nou (7);  list.head.next.next.next.next.next.next.next = nou Nod(8);  Console.WriteLine('Dată lista legată');  list.printList(list.head);  Nodul res = list.reverseUtil(list.head, null);  Console.WriteLine('
Lista legată inversată ');  list.printList(res);  } } // Acest cod a contribuit de Rajput-Ji>>>Javascript>>>  
  Ieșire      Complexitatea timpului:    O(N), vizitând fiecare nod al listei legate de mărimea N.  
    Spațiu auxiliar:    O(N), spațiu pentru stiva de apeluri de funcție
 
    Inversați o listă legată folosind     Ideea este să stocați toate nodurile din stivă, apoi să faceți o listă inversată.
 
Urmați pașii de mai jos pentru a rezolva problema:
 
Stocați nodurile (valorile și adresa) în stivă până când sunt introduse toate valorile.
Odată ce toate intrările sunt finalizate, actualizați indicatorul Head la ultima locație (adică ultima valoare).
Începeți să apară nodurile (valoarea și adresa) și stocați-le în aceeași ordine până când stiva este goală.
Actualizați următorul pointer al ultimului nod din stivă cu NULL.
Mai jos este implementarea abordării de mai sus:
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 = *cap;  while (temp->next != NULL) { // Împinge toate nodurile pentru a stivui s.push(temp);  temp = temp->next;  } *cap = temp;  while (!s.empty()) { // Stocați valoarea de sus a stivei în list temp->next = s.top();  // Pop valoarea din stiva s.pop();  // actualizați următorul pointer din listă temp = temp->next;  } temp->next = NULL; } // Funcție de afișare a elementelor din List void printlist(Node* temp) { while (temp != NULL) { cout<< temp->date<< ' ';  temp = temp->Următorul;  } } // Program pentru a insera din spate a listei legate void insert_back(Node** head, int value) { // am folosit metoda de inserare în spate pentru a introduce valori // în listă. (de exemplu: head->1->2->3->4->Null) Node* temp = nou Nod(valoare);  temp->next = NULL;  // Dacă *head este egal cu NULL if (*head == NULL) { *head = temp;  întoarcere;  } else { Nod* ultimul_nod = *cap;  while (ultimul_nod->next != NULL) last_node = last_node->next;  last_node->next = temp;  întoarcere;  } } // Cod driver int main() { Nod* head = NULL;  insert_back(&cap, 1);  insert_back(&cap, 2);  insert_back(&cap, 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 = new Stack();  Temp nodul = cap;  while (temp.next != null) { // Împinge toate nodurile în stiva s.add(temp);  temp = temp.next;  } cap = temp;  while (!s.isEmpty()) { // Stocați valoarea de sus a stivei în listă temp.next = s.peek();  // Pop valoarea din stiva s.pop();  // actualizați următorul indicator din listă temp = temp.next;  } temp.next = nul;  } // Funcție de afișare a elementelor din Listă static void printlist(Node temp) { while (temp != null) { System.out.print(temp.data + ' ');  temp = temp.next;  } } // Program pentru a insera înapoi în lista legată static void insert_back(int value) { // am folosit metoda de inserare în spate pentru a introduce // valori în listă. (de exemplu: head.1.2.3.4.Null) Node temp = nou Nod(valoare);  temp.next = nul;  // Dacă *head este egal cu null if (head == null) { head = temp;  întoarcere;  } else { Nod ultimul_nod = cap;  while (last_node.next != null) last_node = ultimul_nod.next;  last_node.next = temp;  întoarcere;  } } // Cod driver public static void main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  System.out.print('Dată lista legată
');  printlist(cap);  reverseLL();  System.out.print('
Lista legată inversată
');  printlist(cap);  } } // Acest cod este contribuit de Aditya Kumar (adityakumar129)>>Piton
 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 = Stivă nouă();  Temp nodul = cap;  while (temp.next != null) { // Împinge toate nodurile // în stiva s.Push(temp);  temp = temp.next;  } cap = temp;  while (s.Count != 0) { // Stocați valoarea superioară a // stivei în listă temp.next = s.Peek();  // Pop valoarea din stiva s.Pop();  // Actualizați următorul indicator în // în listă temp = temp.next;  } temp.next = nul;  } // Funcție de afișare // elementele din Listă static void printlist(Node temp) { while (temp != null) { Console.Write(temp.data + ' ');  temp = temp.next;  } } // Funcție de inserare în spatele // listei legate static void insert_back(int val) { // Am folosit metoda de inserare în spate // pentru a introduce valori în listă.(ex: // head.1.2.3.4 .Null) Node temp = new Node(val);  temp.next = nul;  // Dacă *head este egal cu null if (head == null) { head = temp;  întoarcere;  } else { Nod ultimul_nod = cap;  while (last_node.next != null) { last_node = ultimul_nod.next;  } last_node.next = temp;  întoarcere;  } } // Cod driver public static void Main(String[] args) { insert_back(1);  insert_back(2);  insert_back(3);  insert_back(4);  Console.Write('Dată lista legată
');  printlist(cap);  reverseLL();  Console.Write('
Lista legată inversată
');  printlist(cap);  } } // Acest cod este contribuit de gauravrajput1>
 Javascript 
>>>  
  Ieșire      Complexitatea timpului:    O(N), vizitând fiecare nod al listei legate de mărimea N.  
    Spațiu auxiliar:    O(N), Spațiul este folosit pentru a stoca nodurile din stivă.