Operación de la lista vinculada de Java: Lista de enlaces circulares
Principales ejemplos de análisis:
1. Lista recurrente de una sola lista vinculada
2. Lista recurrente de doble lista
Entre ellos, el nodo de lista ligada y la clase de nodo de lista doble y la interfaz iComMoperate <t> son consistentes con el artículo anterior, y no se discutirán aquí. Referencia: Operaciones de la lista vinculada Java: Lista de enlaces único y Lista de doble luz //www.vevb.com/article/95113.htm
1. Lista recurrente de una sola lista vinculada
paquete LinkListTest; import java.util.hashmap; import java.util.map; public class SingLecyClelinkList implementa IComMoperate <node> {private snode head = new Snode ("Head"); // puntero de encabezado público, sin cambios después de la declaración privada int tamiz = 0; public int getsize () {return this.size; } / * * Inserte la lista vinculada, cada vez que se inserta al final, el estándar para determinar si el final apunta a la cabeza * * / @Override public boolean InsertNode (node snode) {boolean flag = false; initLinkList (); // Inicializa la lista vinculada if (this.size == 0) {// vacía de la lista vinculada this.head.setNextNode (nodo); node.setNextNode (this.head); } else {Snode Current = this.head; while (current.getNextNode ()! = this.head) {// busca el nodo final actualmente = current.getNextNode (); } current.setNextNode (nodo); node.setNextNode (this.head); // Sigue la lista Bad Linked, el nodo de cola apunta a la cabeza} this.size ++; bandera = verdadero; Bandera de regreso; } / * * Inserte la posición especificada de la lista vinculada, a partir de 1, y POS es mayor que el tamaño, inserte al final de la lista vinculada * * / @Override public boolean InsertPosNode (int pos, snode nodo) {boolean flag = true; Snode Current = this.head.getNextNode (); initLinkList (); // Inicializa la lista vinculada if (this.size == 0) {// La lista vinculada está vacía this.head.setNextNode (nodo); node.setNextNode (this.head); // Siga la lista Bad Linked, el nodo de cola señala esto.size ++; } else if (this.size <pos) {// La posición POS es mayor que la longitud de la lista vinculada, inserte el end InsertNode (nodo); } else if (pos> 0 && pos <= this.size) {// El nodo en la lista vinculada // 1. Busque el nodo y el nodo anterior que se insertará, y el nodo se insertará entre los dos nodos int find = 0; Snode prenode = this.head; // El nodo delantero SnodeCentNode = Current; // El nodo actual while (busque <pos-1 && currentNode! = This.head) {prenode = current; // El nodo delantero se mueve hacia atrás CurrentNode = currentNode.getNextNode (); // El nodo actual se mueve hacia atrás Find ++; if (busque <pos-1 && cotentNode! = this.head) {// El nodo no está terminado de buscar el nodo, y el nodo se mueve hacia atrás Current = current.getNextNode (); }} // system.out.println (prenode); // system.out.println (currentNode); // 2. Inserte el nodo prenode.setNextNode (nodo); node.setNextNode (CurrentNode); this.size ++; } else {System.out.println ("Error de información de posición"); bandera = falso; } Bandera de retorno; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); }} / * * Especifique el nodo POS de la lista vinculada y elimine el nodo correspondiente. Método: Encuentre los nodos delanteros y traseros para eliminar, eliminar y el subíndice comienza desde 1 * */ @Override public boolean deletenode (int pos) {boolean flag = false; Snode Current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Error de información de posición o ninguna información en la lista vinculada"); } else {// 1. Encuentre los nodos delanteros y posteriores para eliminar int fin fins = 0; Snode prenode = this.head; // Nodo frontal snode nextNode = current.getNextNode (); // El nodo de retroceso while (busque <pos-1 && nextnode! = This.head) {prenode = current; // El nodo delantero se mueve hacia atrás nextNode = nextNode.getNextNode (); // El nodo posterior se mueve hacia atrás Find ++; if (buscar <pos-1 && nextnode! = this.head) {// El nodo frontal no está terminado, la parte posterior "nodo frontal" se mueve hacia atrás corriendo = current.getNextNode (); }} // system.out.println (prenode); // system.out.println (nextNode); // 2. Elimine el nodo prenode.setNextNode (nextNode); System.gc (); // reciclar y eliminar el nodo this.size--; bandera = verdadero; } Bandera de retorno; } / * * Especifique el nodo POS de la lista vinculada, modifique el nodo correspondiente y el subíndice comienza desde 1 * * / @Override public boolean updateTenode (int pos, map <string, object> map) {boolean flak = false; Snode node = getNode (pos, map); // Obtenga el nodo en el pos if (nodo! = Null) {string data = (string) map.get ("data"); node.setData (datos); bandera = verdadero; } Bandera de retorno; } / * * Encuentre el nodo POS de la lista vinculada especificada, y el subíndice comienza desde 1 * * / @Override public snode getNode (int pos, map <string, object> map) {snode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("La información de posición es incorrecta o la lista vinculada no existe"); regresar nulo; } int find = 0; while (encontrar <pos-1 && current! = this.head) {current = current.getNextNode (); encontrar ++; } retorno actual; } / * * Imprima la lista vinculada * * / @Override public void printLink () {int longitud = this.size; if (longitud == 0) {System.out.println ("¡La lista vinculada está vacía!"); devolver ; } Snode Current = this.head.getNextNode (); System.out.println ("Número total de nodos:" + Longitud + "Ones"); int encontrar = 0; while (actual! = this.head) {system.out.println ("th" + (++ find) + "nodos:" + corriente); current = current.getNextNode (); }} public static void main (string [] args) {singlecyclelinkList scll = new SingLecyClelinkList (); Snode node1 = new Snode ("node1"); Snode node2 = new Snode ("node2"); Snode node3 = new Snode ("node3"); Snode node4 = new Snode ("node4"); Snode node5 = new Snode ("node5"); Snode node6 = new Snode ("Insertar posición especificada"); // scll.insertPosNode (scll.getSize ()+1, node1); // scll.insertposnode (scll.getSize ()+1, node2); // scll.insertPosnode (scll.getsize ()+1, node2); // scll.insertPOSNode (scll.getSize ()+1, node3); // scll.insertPosNode (scll.getSize ()+1, node4); // scll.insertposnode (scll.getSize ()+1, node5); scll.insertnode (nodo1); scll.insertnode (nodo2); scll.insertnode (nodo3); scll.insertNode (nodo4); scll.insertnode (nodo5); System.out.println ("*********************************"); scll.printlink (); System.out.println ("************************** obtener el nodo de lista vinculado especificado *****************************************"); int pos = 2; System.out.println ("Obtenga los datos de posición"+POS+"de la lista vinculada:"+scll.getNode (pos, null)); System.out.println ("*********************************"); int pos1 = 3; System.out.println ("Inserte datos en los nodos"+Pos1+":"); scll.insertposnode (POS1, nodo6); scll.printlink (); System.out.println ("*************************** Eliminar el nodo especificado en la lista vinculada ************************************"); int pos2 = 3; System.out.println ("Eliminar"+pos2+"nodos:"); scll.deletenode (pos2); scll.printlink (); System.out.println ("**************************************** Modificar los nodos de ubicación especificados de la lista vinculada ***************************************"); int pos3 = 3; System.out.println ("modificar"+pos3+"nodos:"); Map <string, object> map = new HashMap <> (); map.put ("datos", "Esta es una prueba"); scll.updatenode (pos3, mapa); scll.printlink (); }}2. Lista recurrente de doble lista
paquete LinkListTest; import java.util.hashmap; import java.util.map; public class DoubleCyClelinkList implementa IComMoperate <Dnode> {private dnode head = new dnode ("head"); // puntero de encabezado público, sin cambios después de la declaración privada int tamiz = 0; // Registre el número de nodos de la lista vinculada public int getsize () {return this.size; } / * * Inserte la lista vinculada, cada vez que se inserta al final, el estándar para determinar si el final apunta a la cabeza * * / @Override public boolean InsertNode (nodo dnode) {boolean flag = false; initLinkList (); // Inicializar la lista vinculada dnode corriente = this.head; if (this.size == 0) {// La lista vinculada vacía this.head.setNextNode (nodo); node.setPriornode (this.head); node.setNextNode (this.head); } else {// El nodo en la lista vinculada while (current.getNextNode ()! = this.head) {// busque el nodo final actualmente = current.getNextNode (); } current.setNextNode (nodo); node.setPriornode (actual); node.setNextNode (this.head); // Redirigir la lista de Bad Linked, el nodo de cola apunta a la cabeza} this.size ++; bandera = verdadero; Bandera de regreso; } / * * Inserte la posición especificada de la lista vinculada, a partir de 1, y POS es mayor que el tamaño, inserte el extremo de la lista vinculada * * / @Override public boolean insertposnode (int pos, nodo dnode) {boolean flag = true; initLinkList (); // Inicializar la lista vinculada dnode actualmente = this.head.getNextNode (); if (this.size == 0) {// La lista vinculada está vacía this.head.setNextNode (nodo); node.setPriornode (this.head); node.setNextNode (this.head); this.size ++; } else if (pos> this.size) {// La posición POS es mayor que la longitud de la lista vinculada, inserte el end InsertNode (nodo); } else if (pos> 0 && pos <= this.size) {// El nodo en la lista vinculada // 1. Encuentre el nodo POS a insertar, inserte la posición de corriente de nodo POS int Find = 0; while (busque <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); encontrar ++; } // 2. Insertar nodo if (current.getNextNode () == this.head) {// cola nodo.setPriornode (actual); node.setNextNode (this.head); current.setNextNode (nodo); } else if (current.getNextNode ()! = this.head) {// Intermediate Node Node.SetPriornode (current.getPriornode ()); node.setNextNode (actual); current.getPriornode (). setNextNode (nodo); current.setPriornode (nodo); } this.size ++; } else {System.out.println ("Error de información de posición"); bandera = falso; } Bandera de retorno; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); this.head.setPriornode (this.head); }} / * * Especifique el nodo POS de la lista vinculada y elimine el nodo correspondiente. Método: Encuentre la eliminación del nodo delantera y posterior del nodo que se eliminará, y el subíndice comienza desde 1 * */ @Override public Boolean Deletenode (int POS) {Boolean Flag = false; Dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("La información de posición es incorrecta o la lista vinculada no existe"); } else {// 1. Encuentre el nodo POS de ubicación que se eliminará int Find = 0; while (busque <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); encontrar ++; } // 2. Eliminar el nodo if (current.getNextNode () == this.head) {// Tail Node Current.getPriornode (). SetNextNode (this.head); } else if (current.getNextNode ()! = this.head) {// Intermediate Node Current.getPriOrnode (). SetNextNode (current.getNextNode ()); current.getNextNode (). SetPriornode (current.getPriornode ()); } System.gc (); // Reciclar y eliminar nodos this.size--; bandera = verdadero; } Bandera de retorno; } / * * Especifique el nodo POS de la lista vinculada, modifique el nodo correspondiente y el subíndice comienza desde 1 * * / @Override public boolean updateTenode (int pos, map <string, object> map) {boolean flak = false; Dnode node = getNode (pos, map); if (node! = null) {string data = (string) map.get ("data"); node.setData (datos); bandera = verdadero; } Bandera de retorno; } / * * Encuentre el nodo POS de la lista vinculada especificada, y el subíndice comienza desde 1 * * / @Override public dnode getNode (int pos, map <string, object> map) {dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("La información de posición es incorrecta o la lista vinculada no existe"); regresar nulo; } int find = 0; while (encontrar <pos-1 && current! = this.head) {current = current.getNextNode (); encontrar ++; } retorno actual; } / * * Imprima la lista vinculada * * / @Override public void printLink () {int longitud = this.size; if (longitud == 0) {System.out.println ("¡La lista vinculada está vacía!"); devolver ; } Dnode current = this.head.getNextNode (); int encontrar = 0; System.out.println ("Número total de nodos:" + Longitud + "Ones"); while (actual! = this.head) {system.out.println ("th" + (++ find) + "uno nodos:" + corriente); current = current.getNextNode (); }} public static void main (string [] args) {doubleCyclelinkList dcll = new DoubleCyClelinkList (); Dnode node1 = new DNode ("node1"); Dnode node2 = new DNode ("node2"); Dnode node3 = new DNode ("node3"); Dnode node4 = new DNode ("node4"); Dnode node5 = new DNode ("node5"); Dnode node6 = new DNode ("Insertar la posición especificada"); dcll.insertposnode (10, nodo1); dcll.insertposnode (10, nodo2); dcll.insertposnode (8, nodo3); dcll.insertposnode (88, nodo4); dcll.insertPOSNode (8, node5); // dcll.insertnode (node1); // dcll.insertnode (nodo2); // dcll.sintnode (node3); // dcll.insertnode (node4); // dcll.insertnode (node5); System.out.println ("******************************* Lista vinculada *******************************"); dcll.printlink (); System.out.println ("**********************************"); int pos = 2; System.out.println ("Obtenga los datos de posición"+POS+"de la lista vinculada:"+dcll.getNode (pos, null)); System.out.println ("*************************************** AL NODO EN LA POSICIÓN ESPECIFICADA DE LA LISTA LING *********************************"); int pos1 = dcll.getSize ()+1; System.out.println ("Insertar datos en"+pos1+"nodos:"); dcll.insertposnode (POS1, nodo6); dcll.printlink (); System.out.println ("************************** Eliminar la ubicación de nodo especificada de la lista vinculada **********************************"); int pos2 = 7; System.out.println ("Eliminar"+pos2+"nodos:"); dcll.deletenode (pos2); dcll.printlink (); System.out.println ("*************************************"); int pos3 = 3; System.out.println ("Modifique los nodos"+Pos3+":"); Map <string, object> map = new HashMap <> (); map.put ("datos", "Esta es una prueba"); dcll.Updatenode (POS3, MAP); dcll.printlink (); }}Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!