Operação de lista vinculada ao Java: Lista de links circulares
Principais exemplos de análise:
1 Lista Recorrente Ligada Única
2 Lista recorrente de ligação dupla
Entre eles, o nó da lista de ligações únicas e a classe de nó de lista dupla e a interface iCommoperate <t> são consistentes com o artigo anterior e não serão discutidas aqui. Referência: Operações de lista vinculada ao Java: Lista de ligações únicas e lista de ligações duplas //www.vevb.com/article/95113.htm
1 Lista Recorrente Ligada Única
pacote linklistTest; importar java.util.hashmap; importar java.util.map; classe pública singlecyclelinklist implementa ICommoperate <node> {private snode Head = new Snode ("Head"); // ponteiro de cabeçalho público, inalterado após a declaração private int size = 0; public int getSize () {return this.size; } / * * Insira a lista vinculada, cada vez que é inserida no final, o padrão para determinar se o final está apontando para a cabeça * * / @Override public boolean InsertNode (nó Snode) {sinalizador booleano = false; initLinkList (); // inicialize a lista vinculada se (this.size == 0) {// Lista vinculada vazia this.head.setNextNode (nó); node.setNextNode (this.head); } else {snode atual = this.head; while (current.getNextNode ()! } current.setNextNode (nó); node.setNextNode (this.head); // Siga a lista vinculada ruim, o nó da cauda aponta para a cabeça} this.size ++; bandeira = true; bandeira de retorno; } / * * Insira a posição especificada da lista vinculada, a partir de 1, e POS é maior que o tamanho, insira -a no final da lista vinculada * * / @Override public boolean InsertPosNode (int pos, nó snode) {sinalizador booleano = true; Snode corrente = this.head.getNextNode (); initLinkList (); // inicialize a lista vinculada se (this.size == 0) {// A lista vinculada está vazia this.head.setNextNode (node); Node.SetNextNode (this.head); // Siga a lista vinculada ruim, o nó da cauda aponta para liderar isso.size ++; } else if (this.size <Pos) {// A posição POS é maior que o comprimento da lista vinculada, insira o InsertNode final (nó); } else if (pos> 0 && pos <= this.size) {// O nó na lista vinculada // 1. Encontre o nó e o nó anterior a ser inserido, e o nó será inserido entre os dois nós int find = 0; Snode prenode = this.head; // O nó frontal snode currentNode = current; // O nó atual enquanto (encontre <pos-1 && currentNode! = This.head) {prenode = current; // O nó frontal se move para trás CurrentNode = CurrentNode.getNextNode (); // O nó atual é movido para trás encontrado ++; if (encontre <pos-1 && currentNode! = this.head) {// O nó não termina de procurar o nó, e o nó é movido para trás corrente = current.getNextNode (); }} // System.out.println (prenode); // System.out.println (currentNode); // 2. Insira o nó prenode.setNextNode (nó); node.setNextNode (CurrentNode); this.size ++; } else {System.out.println ("Erro de informação da posição"); bandeira = false; } retornar sinalizador; } private void initLinkList () {if (size == 0) {this.head.setNextNode (this.head); }} / * * Especifique o nó pos da lista vinculada e exclua o nó correspondente. Método: Encontre os nós dianteiros e traseiros para excluir, excluir e o subscrito começa a partir de 1 */ @Override public boolean DeLetenode (int pos) {bandeira booleana = false; Snode corrente = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Posicione erro de informação ou nenhuma informação na lista vinculada"); } else {// 1. Encontre os nós dianteiros e traseiros para excluir int find = 0; Snode prenode = this.head; // nó frontal snode nextNode = current.getNextNode (); // O nó traseiro while (encontre <pos-1 && nextNode! = This.head) {prenode = current; // O nó frontal é movido para trás nextNode = nextNode.getNextNode (); // O nó traseiro é movido de volta Find ++; if (encontre <pos-1 && nextNode! = this.head) {// O nó frontal não está concluído, o "nó frontal" traseiro é movido para trás corrente = current.getNextNode (); }} // System.out.println (prenode); // System.out.println (NextNode); // 2. Exclua o nó prenode.setNextNode (NextNode); System.gc (); // recicle e exclua o nó this.size--; bandeira = true; } retornar sinalizador; } / * * Especifique o nó POS da lista vinculada, modifique o nó correspondente e o subscrito começa a partir de 1 * * / @Override public boolean updateNode (int pos, map <string, object> map) {sinalizador booleano = false; Nó snode = getNode (pos, mapa); // Obtenha o nó no POS correspondente if (node! = Null) {string data = (string) map.get ("dados"); node.setData (dados); bandeira = true; } retornar sinalizador; } / * * Encontre o nó pos da lista vinculada especificada e o subscrito é iniciado de 1 * / @Override public snode getNode (int pos, map <string, objeto> map) {snode atual = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("As informações de posição estão incorretas ou a lista vinculada não existe"); retornar nulo; } int find = 0; while (encontre <Pos-1 && Current! = this.head) {current = Current.getNextNode (); encontre ++; } retornar atual; } / * * Imprima lista vinculada * * / @Override public void printLink () {int length = this.size; if (comprimento == 0) {System.out.println ("A lista vinculada está vazia!"); retornar ; } Snode atual = this.head.getNextNode (); System.out.println ("Número total de nós:" + comprimento + "outros"); int find = 0; while (atual! 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 ("inserir posição especificada"); // scll.insertposnode (scll.getSize ()+1, node1); // scll.insertposnode (scll.getSize ()+1, node2); // scll.insertPosNode (scll.get () 1, node2); // scll.insertPos. scll.insertposnode (scll.getSize ()+1, node3); // scll.insertposnode (scll.getSize ()+1, node4); // scll.insertposnode (scll.getSize ()+1, node5); scll.insertNode (node1); scll.insertNode (node2); scll.insertNode (node3); scll.insertNode (node4); scll.insertNode (node5); System.out.println ("*********************************"); scll.printlink (); System.out.println ("*********************** int pos = 2; System.out.println ("Obtenha os dados de posição"+pos+"da lista vinculada:"+scll.getNode (pos, nulo)); System.out.println ("*********************************"); int pos1 = 3; System.out.println ("Insira dados nos nós"+pos1+":"); scll.insertPosNode (POS1, Node6); scll.printlink (); System.out.println ("************************* int pos2 = 3; System.out.println ("Delete"+POS2+"nós:"); scll.deletenode (POS2); scll.printlink (); System.out.println ("******************************* int pos3 = 3; System.out.println ("modify"+pos3+"nós:"); Mapa <string, object> map = new hashmap <> (); map.put ("dados", "este é um teste"); scll.updatenode (POS3, mapa); scll.printlink (); }}2 Lista recorrente de ligação dupla
pacote linklistTest; importar java.util.hashmap; importar java.util.map; classe pública DoubleCyclelinklist implementa ICommoperate <dnode> {private dnode head = new dnode ("head"); // ponteiro de cabeçalho público, inalterado após a declaração private int size = 0; // Registre o número de nós da lista vinculada public int getSize () {return this.size; } / * * Insira a lista vinculada, cada vez que é inserida até o final, o padrão para determinar se o final está apontando para a cabeça * * / @Override public boolean InsertNode (nó dnode) {bandeira booleana = false; initLinkList (); // Inicialize a lista vinculada dnode Current = this.head; if (this.size == 0) {// a lista vinculada vazia this.head.setNextNode (nó); node.setPriorNode (this.head); node.setNextNode (this.head); } else {// O nó na lista vinculada while (current.getNextNode ()! } current.setNextNode (nó); node.setPriorNode (atual); node.setNextNode (this.head); // redirecionar a lista vinculada ruim, o nó da cauda aponta para a cabeça} this.size ++; bandeira = true; bandeira de retorno; } / * * Insira a posição especificada da lista vinculada, a partir de 1, e POS é maior que o tamanho, insira o final da lista vinculada * * / @Override public boolean insertposnode (int pos, dnode node) {sinalizador booleano = true; initLinkList (); // inicialize a lista vinculada dnode atualmente = this.head.getNextNode (); if (this.size == 0) {// A lista vinculada está vazia this.head.setNextNode (nó); node.setPriorNode (this.head); node.setNextNode (this.head); this.size ++; } else if (pos> this.size) {// A posição POS é maior que o comprimento da lista vinculada, insira o InsertNode final (nó); } else if (pos> 0 && pos <= this.size) {// O nó na lista vinculada // 1. Encontre o nó pos a ser inserido, insira a posição de corrente posse while (encontre <pos-1 && current.getNextNode ()! encontre ++; } // 2. Insira o nó if (current.getNextNode () == this.head) {// Tail Node Node.setPriorNode (Current); node.setNextNode (this.head); current.setNextNode (nó); } else if (current.getNextNode ()! = this.head) {// intermediário node.setPriornode (current.getPriornode ()); node.setNextNode (Current); current.getPriorNode (). SetNextNode (nó); current.setPriorNode (nó); } this.size ++; } else {System.out.println ("Erro de informação da posição"); bandeira = false; } retornar sinalizador; } private void initLinkList () {if (size == 0) {this.head.setNextNode (this.head); this.head.setPriorNode (this.head); }} / * * Especifique o nó pos da lista vinculada e exclua o nó correspondente. Método: Encontre a exclusão do nó frontal e traseiro do nó a ser excluído e o subscrito começa de 1 * */ @Override public boolean Deletenode (int pos) {sinalizador booleano = false; DNode Current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("As informações de posição estão incorretas ou a lista vinculada não existe"); } else {// 1. Encontre o nó de localização a ser excluído int find = 0; while (encontre <pos-1 && current.getNextNode ()! encontre ++; } // 2. Exclua o nó if (current.getNextNode () == this.head) {// Tail Node Current.getPriornode (). SetNextNode (this.head); } else if (current.getNextNode ()! = this.head) {// intermediário nó current.getPriornode (). SetNextNode (current.getNextNode ()); current.getNextNode (). SetPriornode (current.getPriornode ()); } System.gc (); // Recicle e exclua nós. bandeira = true; } retornar sinalizador; } / * * Especifique o nó POS da lista vinculada, modifique o nó correspondente e o subscrito começa a partir de 1 * * / @Override public boolean updateNode (int pos, map <string, object> map) {sinalizador booleano = false; Nó dnode = getNode (pos, mapa); if (node! = null) {string data = (string) map.get ("dados"); node.setData (dados); bandeira = true; } retornar sinalizador; } / * * Encontre o nó POS da lista vinculada especificada e o subscrito começa a partir de 1 * / @Override public dnode getNode (int pos, map <string, object> map) {dnode atual = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("As informações de posição estão incorretas ou a lista vinculada não existe"); retornar nulo; } int find = 0; while (encontre <Pos-1 && Current! = this.head) {current = Current.getNextNode (); encontre ++; } retornar atual; } / * * Imprima lista vinculada * * / @Override public void printLink () {int length = this.size; if (comprimento == 0) {System.out.println ("A lista vinculada está vazia!"); retornar ; } DNode Current = this.head.getNextNode (); int find = 0; System.out.println ("Número total de nós:" + comprimento + "outros"); while (atual! current = current.getNextNode (); }} public static void main (string [] args) {doubleCyclelinklist dcll = new DoubleCycLelinkList (); Dnode node1 = new dnode ("node1"); Dnode node2 = novo dnode ("node2"); Dnode node3 = novo dnode ("node3"); Dnode node4 = novo dnode ("node4"); Dnode node5 = novo dnode ("node5"); Dnode node6 = novo dnode ("Inserir posição especificada"); dcll.insertposnode (10, node1); dcll.insertposnode (10, node2); dcll.insertposnode (8, node3); dcll.insertposnode (88, node4); dcll.insertposnode (8, node5); // dcll.insertNode (node1); // dcll.insertNode (node2); // dcll.insertNode (node3); // dcll.insertNode (node4); // Dcll.insertNode (node); System.out.println ("****************************** Lista vinculada de saída *********************************"); dcll.printlink (); System.out.println ("************************************"); int pos = 2; System.out.println ("Get os dados de posição"+pos+"da lista vinculada:"+dcll.getNode (pos, null)); System.out.println ("****************************** Insira o nó na posição especificada da lista vinculada ************************************"); int pos1 = dcll.getSize ()+1; System.out.println ("Insira dados em"+pos1+"nós:"); dcll.insertposnode (POS1, Node6); dcll.printlink (); System.out.println ("************************ Exclua o nó local especificado da lista vinculada ************************************"); int pos2 = 7; System.out.println ("Delete"+POS2+"nós:"); dcll.deletenode (POS2); dcll.printlink (); System.out.println ("***************************************"); int pos3 = 3; System.out.println ("modifique os nós"+pos3+":"); Mapa <string, object> map = new hashmap <> (); map.put ("dados", "este é um teste"); dcll.updatenode (POS3, mapa); dcll.printlink (); }}Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!