Este artigo compartilha o código relevante para o Java para implementar listas de ligamento único e listas vinculadas de mão dupla para sua referência. O conteúdo específico é o seguinte
Java implementa uma lista vinculada única:
Código do pacote; classe nó {node a seguir; int dados; public node (int dados) {this.data = data; }} classe linkList {node primeiro; // Chefe public linkList () {this.first = null; } public void addNode (nó no) {No.Next = primeiro; primeiro = não; // adicione a cabeça} public void deLectNode () {node n = primeiro.next; primeiro = nulo; primeiro = n; // excluir na cabeça} // excluir a posição especificada public int number () {int count = 1; // Veja quantos elementos existem nó nd = primeiro; while (nd.next! = null) {nd = nd.next; contagem ++; } contagem de retorno; } public void DeLectExact (int n) {// Exclua a posição especificada se (n> 1) {int count = 1; Nó de = primeiro; while (count <n-1) {de = de.next; contagem ++; } de.next = de.next.next; } else primeiro = primeiro.next; } public void addExact (int n, nó nd) {if (n> 1) // Adicione a posição especificada {int conting = 1; Nó de = primeiro; while (count <n-1) {de = de.next; contagem ++; } nd.Next = de.next; de.next = nd; } else primeiro = primeiro.next; } public int findNode (int n) {int count = 1; // Encontre a posição correspondente a um nó numérico de = primeiro; while (de.data! = n) {de = de.next; contagem ++; if (de == null) {return -1; }} Retornar contagem; } public void print () {nó no = primeiro; // imprima todo (não! = null) {System.out.println (No.Data); Não = No.Next; }}} classe pública TextNode {public static void main (string [] args) {linkList ll = new LinkList (); ll.addnode (novo nó (12)); ll.addnode (novo nó (15)); ll.addnode (novo nó (18)); ll.addnode (novo nó (19)); ll.addnode (novo nó (20)); /*System.out.println(ll.first.data); LL.DELECTNODE (); System.out.println (ll.first.data);*/ system.out.println (ll.number ()); LL.DELECTEXACT (3); ll.addexact (3, novo nó (100)); System.out.println (ll.number ()); // ll.print (); System.out.println (ll.findnode (112)); }}Java implementa a lista vinculada de mão dupla:
classe pública Doublelink {public static void main (string [] args) {node2 no = new Node2 (5); No.Addleft (novo Node2 (6)); No.Addright (novo Node2 (7)); /*no.print (); No.Print2 ();*/ No.AdDexAct2 (1, novo Node2 (8)); No.Print (); System.out.println ("-----------------"); No.Print2 (); }} classe node2 {public node2 primeiro; Public Node2 End; public node2 restante; Public Node2 Certo; int data = 0; public node2 (int n) {primeiro = this; fim = this; primeiro.data = n; } // Adicione o vazio público do addleft da cabeça (node2 antes) {primeiro.left = antes; antes.right = primeiro; primeiro = antes; } // Adicione o vazio público da cauda adicional (node2 depois) {end.right = depois; depois.left = end; fim = depois; } // Insira o número de public void addExact (int n, node2 no) {int count = 0; if (n == 0) {addleft (não); } else {node2 f = primeiro; while (true) {f = f.right; contagem ++; if (count == n) {// Esta é a alteração no salto dos quatro ponteiros No.Left = f.left; f.Left.right = não; // primeiro.left = não; Não. f.left = não; quebrar; }}}}} // insira o número de public void addExAct2 (int n, node2 no) {int conting = 0; if (n == 0) {addright (não); } else {node2 f = end; while (true) {f = f.left; contagem ++; if (count == n) {No.Left = f; Não. f.right.left = não; f.right = não; quebrar; }}}}} // positivo de traversal public void print () {System.out.println (primeiro.data); while (primeiro.right! = null) {System.out.println (primeiro.right.data); primeiro = primeiro.right; } // System.out.println (end.data); } // Ordem reversa Traversal public void print2 () {System.out.println (end.data); while (end.left! = null) {System.out.println (end.left.data); end = end.left; }}}/*Vale ressaltar que toda vez que um novo objeto é inserido, você precisa prestar atenção à mudança de ponteiro apontando. Primeiro, o apontar de ambos os lados deste novo objeto (esquerda e direita), seguido pelos apontamentos do objeto esquerdo para a direita e o apontamento do objeto direito para a esquerda. O apontamento desses quatro ponteiros deve estar correto, caso contrário, pode levar à incapacidade de implementar a travessia de ordem positiva ou reversa. *//*Compare listas vinculadas únicas, listas vinculadas únicas só podem ser atravessadas de uma direção, porque há apenas uma cabeça, enquanto uma lista vinculada bidirecional tem uma cabeça e uma cauda. Pode ser atravessado da cabeça * ou da cauda. Além disso, como um dos objetos tem ponteiros em duas direções, ele pode obter o * Objeto à esquerda e o objeto à direita. * Mas para listas de liga única, porque há apenas uma direção, elas só podem ir para a esquerda ou direita. Ao adicionar objetos, você também pode adicioná -los desde o início ou desde o final. * Se uma única lista vinculada precisar adicionar duas direções, é raro, ou não, porque só tem ponteiros para uma direção para a esquerda ou direita*, enquanto cada objeto de uma lista vinculada bidirecional tem ponteiros para duas direções, o que não é mais flexível, mas isso também tem desvantagens, porque dessa maneira, cada objeto* contém dois poinadores, que também terão consumo. * * */O exposto acima é tudo sobre este artigo, espero que seja útil para todos aprenderem a programação Java.