Este blog es relativamente simple. Solo mire el orden inverso de las listas vinculadas individuales si no lo entiende.
Idea de orden inverso
Ahora suponga que hay una lista vinculada, que se operará en orden inverso. Lo primero que pensamos es revertir la relación de puntero.
De hecho, eso es todo. El blogger es una sola operación de orden inverso de la lista vinculada con este objetivo.
Nodo pre = null; nodo post = null; while (head! = Null) {post = head.next; head.next = pre; pre = cabeza; cabeza = post;}Este es el núcleo del orden inverso. Expliquemos paso a paso.
Al principio, Pre y Post están configurados para NULL. Esto es necesario porque después de la línea de ejecución de código de Head.next = pre, el siguiente de nuestro nodo principal original se volverá nula, es decir, el nulo de toda nuestra lista vinculada.
¿Imagina que el siguiente al final de la lista de enlaces original también es un nulo? La verdad aquí es la misma.
En este momento, la actualización PRE al nodo de cabeza original también se prepara para el siguiente paso de orden inverso, y la cabeza se convierte naturalmente en la cabeza original.
Lo siento, mi mano tembló y lo sacé mal. Gracias a todos. La quinta vez en el diagrama dibujado a mano indica que el nodo previo debe estar en la posición del nodo 5 y no hay cabeza.
No es difícil ver en la leyenda que movemos la cabeza hacia atrás una y otra vez, y actualizamos el nodo previo al mismo tiempo para lograr el efecto del orden inverso.
Código
Lista de paquetes; public Class Reverselist {public static void main (string [] args) {nodo head = new node (1); int [] value = {2,3,4,5}; nodo temp = head; for (int i = 0; i <valor.length; i ++) {nodo = nuevo nodo (valor [i]); temp.next; temp.next;} printList (head); // inverso El orden de salida un solo cabezal de lista vinculada = reversa (head); printList (head); // revertir la cabeza nuevamente = reversesingLelist (head); imprimeList (head);} public static void impintList (head de nodo) {while (head! = null) {system.out.print ("/T" head.next;} system.out.println ();} public static nodo reverse (nodo head) {nodo pre = null; node post = null; while (head! = null) {post = head.next; head.next = pre; pre = head; hEAD = post;} return pre;} Public estatic nodo reversa reversaList (nodo de nodo) {nodo node) null; while (head! = null) {next = head.next; head.next = pre; pre = head; head = next;} return pre;}} class nodo {public int value; public nodo Next; public nodo (int value) {this.value = valor;}}}}}}}}prueba
Después de la prueba, la salida del código es correcta.
1 2 3 4 5
5 4 3 2 1
1 2 3 4 5
Para ayudar a comprender, aquí hay otro ejemplo:
/** * Java implementa el orden inverso de listas vinculadas únicas * @author administrador * */public class SingLelinkedReverse {class node {int data; node next; public node (int data) {this.data = data;}} public static void main (string [] args {singleinkedreinver slr = newing singlinkedReverse (); node, node, node, node, node, node, node, node, node, node, node, node, node, node, node, node; Slr.Node Node (0); para (int i = 1; i <10; i ++) {nodo p = slr.New node (i); tail.next = p; tail = p;} tail = while (tail! = null) {system.out.print (tail.data+""); cola = tail.next;} head = reverse (reverso); system.out.print ("" "); while (head! = null) {system.out.print (head.data+""); head = head.next;}} private static nodo reverse (nodo head) {node p1, p2 = null; p1 = head; while (head.next! = null) {p2 = head.next; head.next = p2.next; p2.next = p1; p1; P2;}}Resultados de la prueba:
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0
Resumir
Lo anterior es todo el contenido de este artículo sobre el ejemplo de código de uso de orden inverso de listas vinculadas de Java. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!