Revertir una lista vinculada

Cómo revertir una lista vinculada en C ++ se muestra en este tutorial de Linuxhint. Cuando invierte una lista vinculada, la ruta del enlace se invierte y la cabeza se convierte en la cola, y la cola se convierte en la cabeza. Al cambiar las posiciones de los nodos, podemos entender esto rápidamente. En este intercambio, simplemente cambiamos las posiciones de los nodos de izquierda a derecha o viceversa.

lista enlazada: Esta es una lista vinculada que queremos revertir.

Después de la lista vinculada invertida: El siguiente será el resultado después de revertir la lista de arriba vinculada.

En el diagrama de ejemplo anterior, podemos ver que el nodo de cabeza y el nodo de cola cambian sus posiciones cuando revertimos la lista vinculada. El nodo head, que ahora es un nodo de cola, apunta al nodo nulo porque ahora es un nodo de cola.

Pasos de algoritmo

1. Creamos un método principal y declaramos algunas variables requeridas.
2. Luego, nuestro siguiente paso es crear un método que pueda crear una lista vinculada. Este método nos ayuda a crear una lista vinculada.
3. El siguiente paso es crear un método para revertir la lista vinculada. En este método, pasamos toda la lista vinculada, y este método revertirá la lista vinculada.
4. Ahora, necesitamos otro método para mostrar nuestro resultado después de revertirlo.
5. Combinaremos todos estos métodos anteriores en nuestro método principal.

Vamos a explicar la lista vinculada invertida utilizando algún formulario pictórico para facilitar. Así que comencemos con el ejemplo.

La siguiente es una lista vinculada que queremos revertir.

Paso 1. El nodo de color verde es un nodo principal, que apunta al primer nodo en el inicio.

Paso 2. En el siguiente paso, atravesaremos toda la lista vinculada hasta que no obtengamos el puntero nulo al lado del nodo del encabezado. Para eso, vamos a asignar al siguiente nodo un nombre temporal, como se muestra en el siguiente diagrama.

Paso 3. Como tenemos un nuevo nodo de referencia llamado "temporal", que puede ayudarnos a atravesar toda la lista vinculada hasta que no obtengamos el puntero nulo, por lo que podemos establecer el siguiente enlace del nodo de encabezado como nulo, que no afectará el vinculado Lista como se muestra a continuación en el diagrama. El puntero nulo al lado del nodo actual se llama el nodo anterior.

Etapa 4. Ahora, movemos el nodo temporal al siguiente nodo y el nodo actual al nodo temporal anterior. Así que ahora nos hemos mudado al siguiente nodo. También cambiamos el nodo anterior de NULL a solo el nodo anterior del nodo actual. Entonces, ahora el nodo temporal se encargará de todos los recorridos hasta el puntero nulo para que podamos establecer el enlace del nodo actual al nodo anterior, y ahora apunta al nodo anterior, como se muestra en el siguiente diagrama.

Así que seguimos los mismos pasos y, por fin, obtendremos una lista vinculada en VITRADO.

Paso 5.

Paso 6.

Paso 7.

Paso 8.

Paso 9.

Paso 10.

Paso 11.

Paso 12.

Paso 13.

Paso 14. En este paso, nuestra lista vinculada se invirtió.

Programa C ++ para revertir una lista vinculada

#incluir
usando el espacio de nombres STD;
// método para crear el nodo
nodo de estructura
valor int;
nodo *nextNodePtr;
*nodeObject;
nulo createLinkedList (int n);
Void ReverselinkedList (nodo ** nodeObject);
visualización vacía ();
int main ()
int n, valor, elemento;
cout<<"How many nodes you want to create =>: ";
cin >> n;
CreateLinkedList (n);
cout<<"\nInformation in the linked list: \n";
mostrar();
cout<<"\nLinked list after reversed\n";
ReverselinkedList (& nodeObject);
mostrar();
regresar 0;

// Este método creará la lista vinculada
void createLinkedList (int n)
struct node *frontnode, *tempnode;
valor int, i;
nodeObject = (struct nodo *) malloc (sizeOf (nodo struct));
if (nodeObject == null)
cout<<" Not enough to assing memory";
demás
cout<<"Please enter the info of node 1 (number only): ";
Cin >> valor;
nodeObject-> valor = valor;
nodeObject-> nextNodePtr = null;
tempnode = nodeObject;
para (i = 2; i<=n; i++)
frontNode = (struct nodo *) malloc (sizeOf (nodo struct));
// Cuando no hay ningún nodo en la lista vinculada
if (frontNode == null)
cout<<"Memory can not be allocated";
romper;

demás
cout<<"Please enter the info of node "<Cin >> valor;
frontNode-> value = value;
frontNode-> nextNodePtr = null;
tempNode-> nextNodePtr = frontNode;
tempNode = tempNode-> nextNodePtr;




Void ReverselinkedList (nodo ** nodeObject)
struct node *tempnode = null;
struct node *previonode = null;
struct node *currentNode = ( *nodeObject);
while (currentNode != Nulo)
tempNode = centreRNode-> nextNodePtr;
actionNode-> nextNodePtr = previonode;
AnteriorNode = CurrentNode;
actualnode = tempNode;

(*NodeObject) = AnteriorNode;

visualización void ()
struct nodo *tempnode;
if (nodeObject == null)
cout<<"Linkedlist is empty";

demás
tempnode = nodeObject;
mientras (tempnode != Nulo)

cout<valor<<"\t";
tempNode = tempNode-> nextNodePtr;


cout <

Producción

¿Cuántos nodos quieres crear =>: 6
Ingrese la información del nodo 1 (solo número): 101
Ingrese la información del nodo 2: 95
Ingrese la información del nodo 3: 61
Ingrese la información del nodo 4: 19
Ingrese la información del nodo 5: 12
Ingrese la información del nodo 6: 11
Información en la lista vinculada:
101 95 61 19 12 11
Lista vinculada después de revertir
11 12 19 61 95 101

Conclusión

Este artículo de Linuxhint ha revisado cómo revertir una lista vinculada en C++. Existen algunos otros métodos para revertir una lista vinculada, pero este es un método muy común para revertir una lista vinculada. Depende de usted decidir cómo desea resolver sus problemas, pero generalmente la función de lista vinculada inversa debe ser un bucle simple con swaps de puntero.