Cómo Invertir una Lista Enlazada

La solución de la profe en Java, reverseLinkedList método que va en la clase ListaEnlazada realizada en la sección previa, Java no permite la asignación paralela como en Python, por lo cual se usa la variable temp:

    public void reverseLinkedList() { 
        Nodo anterior = null;
        Nodo temp = null;
        Nodo cabezaInicial = this.cabeza;
        Nodo colaInicial = this.cola;
        
        while (this.cabeza != null) {
            temp = this.cabeza.siguiente; // Guardamos el Nodo cabeza.siguiente 
            this.cabeza.siguiente = anterior;	
            
            if ((this.cabeza.equals(colaInicial))) {
                /*
                 * Cuando llegamos al útlimo Nodo de la lista, que ahora es cabeza,
                 * al Nodo cola le asignamos el Nodo cabeza inicial, es decir
                 * al Nodo cola le asignamos el Nodo con el cual se inició el recorrido del while.
                 */
                this.cola = cabezaInicial;
                break;
            }
            
            anterior = this.cabeza;
            this.cabeza = temp;
        } 
    }

Cuando llegamos al último Nodo de la lista, se rompe el while antes de anterior = this.cabeza; this.cabeza = temp;, para que Nodo cabeza no apunte a null y para no hacer una asignación demás a Nodo anterior.

Code to Reverse a LinkedList by C .\n ```js #include<stdio.h> #include <stdlib.h> int p = 0; //Definition for a linked list node here ..... struct node { int data; struct node *next; }; struct node *head = NULL; void addFirst(int val) { //Write your code here.... struct node *newNode = malloc(sizeof( struct node)); newNode->data = val; newNode->next = head; head = newNode; } void deleteNode(struct node **head, int key) { //Write your code here.... struct node *temp; if ( (*head)->data == key ) { temp = *head; *head = (*head)->next; free(temp); } else { struct node *current = *head; while ( current->next != NULL ) { if ( current->next->data == key ) { temp = current->next; current->next = current->next->next; free(temp); break; } else { current = current->next; } } } } //Don't change the below code void addLast(struct node **head, int val) { struct node *newNode = malloc(sizeof(struct node)); newNode->data = val; newNode->next = NULL; if(*head == NULL) *head = newNode; else { struct node *lastNode = *head; while(lastNode->next != NULL) { lastNode = lastNode->next; } lastNode->next = newNode; } } void printList(struct node *head) { struct node *temp = head; while(temp != NULL) { printf("%d ", temp->data); temp = temp->next; } } void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; } //Function to Reverse a LinkedList from last element to head .... void reverse(struct node *head) { struct node *current = head ; struct node *prev = NULL ; struct node *n3xt = NULL ; while ( current != NULL ) { n3xt = current->next ; current->next = prev ; prev = current ; current = n3xt ; } head = prev ; } struct node* reverseSubList(struct node *head, int start, int end) { if ( start == end ) return head ; struct node *current = head; struct node *prev = NULL ; int i = 0; for ( i = 1 ; current != NULL && i < start ; i ++ ) { prev = current ; current = current->next ; } struct node *firstPartLastNode = prev; struct node *secondPartLastNode = current ; struct node *next ; for ( i = 1 ; current != NULL && i <= end - start + 1 ; i ++ ) { next = current->next; current->next = prev; prev = current; current = next; } if ( firstPartLastNode != NULL ) firstPartLastNode->next = prev ; else head = prev ; secondPartLastNode->next = current ; } int main ( void ) { struct node *head = NULL; addLast(&head,10); addLast(&head,20); addLast(&head,30); addLast(&head,40); addLast(&head,50); addLast(&head,60); addLast(&head,70); addLast(&head,80); addLast(&head,90); int key; scanf("%d",&key); deleteNode(&head, key); printList(head); reverse(head) ; printf("++++++++++++++000\n") ; printList( head ) ; printf("\n"); return 0 ; } ``` \#include\<stdio.h> \#include \<stdlib.h> int p = 0; //Definition for a linked list node here ..... struct node { int data; struct node \*next; }; struct node \*head = NULL; void addFirst(int val) { //Write your code here.... struct node \*newNode = malloc(sizeof( struct node)); newNode->data = val; newNode->next = head; head = newNode; } void deleteNode(struct node \*\*head, int key) { //Write your code here.... struct node \*temp; if ( (\*head)->data == key ) { temp = \*head; \*head = (\*head)->next; free(temp); } else { struct node \*current = \*head; while ( current->next != NULL ) { if ( current->next->data == key ) { temp = current->next; current->next = current->next->next; free(temp); break; } else { current = current->next; } } } } //Don't change the below code void addLast(struct node \*\*head, int val) { struct node \*newNode = malloc(sizeof(struct node)); newNode->data = val; newNode->next = NULL; if(\*head == NULL) \*head = newNode; else { struct node \*lastNode = \*head; while(lastNode->next != NULL) { lastNode = lastNode->next; } lastNode->next = newNode; } } void printList(struct node \*head) { struct node \*temp = head; while(temp != NULL) { printf("%d ", temp->data); temp = temp->next; } } void swap(int \*x, int \*y) { int temp = \*x; \*x = \*y; \*y = temp; } //Function to Reverse a LinkedList from last element to head .... void reverse(struct node \*head) { struct node \*current = head ; struct node \*prev = NULL ; struct node \*n3xt = NULL ; while ( current != NULL ) { n3xt = current->next ; current->next = prev ; prev = current ; current = n3xt ; } head = prev ; } struct node\* reverseSubList(struct node \*head, int start, int end) { if ( start == end ) return head ; struct node \*current = head; struct node \*prev = NULL ; int i = 0; for ( i = 1 ; current != NULL && i < start ; i ++ ) { prev = current ; current = current->next ; } struct node \*firstPartLastNode = prev; struct node \*secondPartLastNode = current ; struct node \*next ; for ( i = 1 ; current != NULL && i <= end - start + 1 ; i ++ ) { next = current->next; current->next = prev; prev = current; current = next; } if ( firstPartLastNode != NULL ) firstPartLastNode->next = prev ; else head = prev ; secondPartLastNode->next = current ; } int main ( void ) { struct node \*head = NULL; addLast(\&head,10); addLast(\&head,20); addLast(\&head,30); addLast(\&head,40); addLast(\&head,50); addLast(\&head,60); addLast(\&head,70); addLast(\&head,80); addLast(\&head,90); int key; scanf("%d",\&key); deleteNode(\&head, key); printList(head); reverse(head) ; printf("++++++++++++++000\n") ; printList( head ) ; printf("\n"); return 0 ; }

Codigo en TS: ```js function reverseList(head: ListNode | null): ListNode | null { let [p1, p2] = [head, null]; while (p1 != null) { p2 = new ListNode(p1.val, p2); p1 = p1.next; } return p2; }; ```function reverseList(head: ListNode | null): ListNode | null { let \[p1, p2] = \[head, null]; while (p1 != null) { p2 = new ListNode(p1.val, p2); p1 = p1.next; } return p2;};

```python class Node: def __init__(self, data): self.data = data self.next = None self.prev = None def __str__(self): return str(self.data) class Lista: def __init__(self): self.head, self.tail= None, None def __len__(self): length = 0 current = self.head while current: length += 1 current = current.next return length def append(self, data): new_node = Node(data) if self.head is None: self.head = new_node else: self.tail.next = new_node # Update the next pointer of the current tail node self.tail = new_node # Update the tail attribute to point to the new node return f'{data} has been added' def __str__(self): result = [] current = self.head while current: result.append(str(current)) current = current.next return ' -> '.join(result) + f', tail => {self.tail}' # Add tail information to the string representation def reverse(self): current = self.head previous = None while current != None: current.next, previous, current = previous, current, current.next self.head = previous return previous # Example usage: my_list = Lista() my_list.append(1) my_list.append(2) my_list.append(3) my_list.append(4) my_list.append(30) print(my_list) my_list.reverse() print(my_list) ```output  1 -> 2 -> 3 -> 4 -> 30, tail => 30 30 -> 4 -> 3 -> 2 -> 1, tail => 30

```python class Node: def __init__(self, data): self.data = data self.next = None self.prev = None def __str__(self): return str(self.data) class Lista: def __init__(self): self.head, self.tail= None, None def __len__(self): length = 0 current = self.head while current: length += 1 current = current.next return length def append(self, data): new_node = Node(data) if self.head is None: self.head = new_node else: self.tail.next = new_node # Update the next pointer of the current tail node self.tail = new_node # Update the tail attribute to point to the new node return f'{data} has been added' def __str__(self): result = [] current = self.head while current: result.append(str(current)) current = current.next return ' -> '.join(result) + f', tail => {self.tail}' # Add tail information to the string representation def reverse(self): current = self.head previous = None while current != None: current.next, previous, current = previous, current, current.next self.head = previous return previous # Example usage: my_list = Lista() my_list.append(1) my_list.append(2) my_list.append(3) my_list.append(4) my_list.append(30) print(my_list) my_list.reverse() print(my_list) ```class Node:    def \_\_init\_\_(self, data):        self.data = data        self.next = None        self.prev = None     def \_\_str\_\_(self):        return str(self.data) class Lista:     def \_\_init\_\_(self):        self.head, self.tail= None, None     def \_\_len\_\_(self):        length = 0        current = self.head        while current:            length += 1             current = current.next        return length        def append(self, data):        new\_node = Node(data)        if self.head is None:            self.head = new\_node        else:            self.tail.next = new\_node  # Update the next pointer of the current tail node        self.tail = new\_node  # Update the tail attribute to point to the new node        return f'{data} has been added'        def \_\_str\_\_(self):        result = \[]        current = self.head        while current:            result.append(str(current))            current = current.next         return ' -> '.join(result) + f', tail => {self.tail}'  # Add tail information to the string representation        def reverse(self):        current = self.head        previous = None        while current != None:            current.next, previous, current = previous, current, current.next        self.head = previous        return previous    # Example usage:my\_list = Lista()my\_list.append(1)my\_list.append(2) my\_list.append(3)my\_list.append(4) my\_list.append(30)print(my\_list) my\_list.reverse()print(my\_list)

Hice la prueba con el codigo de la profe, y solo devolvia el primer nodo, toca quitarle el return y agregarle el cambio de cabeza con la cola:
self.head, self.tail = self.tail, self.head
.
comparto código con pruebas

.
Pruebas:

Otra solución:
Con Java, método dentro de la clase ListaEnlazada.

Mover el nodo cabeza y colocarlo entre el nodo cola y lo que apuntaba el nodo cola (esto se almacena en la aux para no perder esa parte de la lista). El nodo cola siempre será el mismo durante toda el recorrido del while hasta que éste se convierta en actual y sea el primero de la lista y se lo asignemos a la cabeza.

Ej.: 1 -> 2 -> 3 -> 4

1. Primera iteración: Movemos el 1 entre 4 y el null
   2 -> 3 -> 4 -> 1

2. Segunda iteración. Movemos el 2 entre el 4 y el 1
   3 -> 4 -> 2 -> 1

3. Tercera iteración: Movemos el 3 entre el 4 y el 2
   4 -> 3 -> 2 ->1

Como actual = 4 y es igual al Nodo colaInicial rompemos el ciclo y nuestra lista estará reversada.

    public void reversarListaEnlazada() {
        
        Nodo colaInicial = this.cola;          //Guardamos el Nodo cola inicial
        Nodo cabezaInicial = this.cabeza;      //Guardamos el Nodo cabeza inicial
        Nodo actual = this.cabeza;
        Nodo aux = null;
        
        while (actual.siguiente != null) {
            if (actual.equals(colaInicial)) {    
                /*
                 * Si el nodo actual es igual al Nodo colaInicial,
                 * cambiamos por primera vez el puntero del nodo cola,
                 * y se lo asignamos al Nodo cabezaInicial.
                 */
                this.cola = cabezaInicial;
                break;
            } 
            actual = actual.siguiente;
            aux = this.cola.siguiente;
            this.cola.siguiente = this.cabeza;
            this.cabeza.siguiente = aux;
            this.cabeza = actual;
        }
    }