Prefácio
Uma lista vinculada é uma estrutura de dados básica comum. É uma tabela linear, mas não é armazenada sequencialmente na memória. É armazenado em forma de corrente. Cada nó armazena o "ponteiro" do próximo nó. Os dados em Java são divididos em tipos de dados de referência e tipos de dados básicos. Não existe um conceito de ponteiros em Java, mas para listas vinculadas, os ponteiros se referem ao endereço dos tipos de dados de referência.
Listas e matrizes vinculados são estruturas de dados lineares e seu comprimento é corrigido para matrizes. Como são contínuos na memória, eles são mais adequados para pesquisa e travessia. As listas vinculadas não são armazenadas sequencialmente na memória, mas como são compostas por "ponteiros", é mais conveniente comparar matrizes ao inserir e excluir.
O código a seguir implementa uma estrutura de dados simples de uma lista vinculada descrita no idioma Java por meio de classes internas e métodos recursivos. Vamos dar uma olhada na introdução detalhada.
Definição de estrutura de dados da lista vinculada
Primeiro, vamos dar uma olhada na definição da estrutura de dados da lista vinculada, o código é o seguinte:
classe NodeManager {private node root; // nó raiz privado int currentIndex = 0; // Nó número de série, cada operação inicia a partir de 0 public void add (int dados) {} public void delnode (int dados) {} public void print () {} public boolean findNode (int dados) {}} insert public publicenode (Int OldData, int newdata) {} // Insert public, public wextAnode (int antigo, int newdata) {} // insert public void, a classe de método nó {private int dados; nó privado a seguir; // Pegue o tipo atual como um nó público da propriedade (int dados) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {retornar dados; } // Adicione nó public void addNode (int dados) {} // Excluir nó public void delnode (int data) {} // emitir todos os nós public void printNode () {} // descobrir se o node existe public boolean findnode (int) {} // Modify node integronean update nó public void insertNode (int index, int dados) {}}}Para a definição de listas vinculadas, a classe NodeManager é usada para gerenciar operações de lista vinculadas, enquanto o nó da classe interna do membro é usado para fornecer dados de lista vinculados e estrutura da cadeia. Para os usuários da classe, os dados não são acessados diretamente; portanto, a classe NodeManager opera e o nó da classe interna fornece gerenciamento de dados real. Portanto, a classe Node precisa fornecer métodos de operação de dados reais, e a classe NodeManager também precisa fornecer um conjunto de métodos para operar listas vinculadas por externamente. Portanto, tanto a classe NodeManager quanto a classe de nó fornecem aparentemente os mesmos métodos, mas o significado real não é o mesmo.
Vamos verificar o método add () na classe NodeManager e na classe Node. O código é o seguinte:
public void add (int dados) {if (root == null) {root = new Node (dados); } else {root.addnode (dados); }} // Adicione nó public void addNode (int dados) {if (this.Next == null) {this.Next = new Node (Data); } else {this.next.addnode (dados); }}O método acima no código é o método na classe NodeManager, enquanto o método a seguir é o método na classe Node.
Uma variável de membro raiz é fornecida na classe do gerente, que é usada para gerenciar o nó da cabeça da lista vinculada. Portanto, ao adicionar um nó, primeiro determinará se a raiz está vazia. Se estiver vazio, o nó será salvo diretamente pela raiz. Se a raiz não estiver vazia, ela será adicionada através do método addNode () na classe Node. A idéia de adicionar ao ponto é encontrar o último nó da lista atual vinculada e atribuir a nova adição à próxima variável de membro de que o nó está atribuído ao último nó.
Adicione, exclua, modifique e verifique a lista vinculada
A mesma idéia também é dada a outras operações em listas vinculadas. O código completo para adicionar, excluir, recuperar e sair das listas vinculadas é a seguinte:
classe NodeManager {private node root; // nó raiz privado int currentIndex = 0; // Nó número de série, cada operação é iniciada a partir de 0 public void add (int dados) {if (root == null) {root = new Node (dados); } else {root.addnode (dados); }} public void delnode (int dados) {if (root == null) return; if (root.getData () == dados) {node tmp = root; root = root.next; tmp = nulo; } else {root.delnode (dados); }} public void print () {if (root! = null) {System.out.print (root.getData () + ""); root.printNode (); System.out.println (); }} public boolean findNode (int dados) {if (root == null) retorna false; if (root.getData () == data) {return true; } else {return root.findnode (dados); }} public boolean updateNode (int anticData, int newData) {if (root == null) return false; if (root.getData () == OldData) {root.setData (newData); retornar true; } else {return root.updatenode (OldData, newData); }} // Insira o public void insert (int index, int data) {if (index <0) return; currentIndex = 0; if (index == currentIndex) {node newNode = new Node (dados); newNode.Next = root; root = newNode; } else {root.insertNode (index, dados); }} // Quem possui os dados, que fornece a classe de método nó {private int Data; nó privado a seguir; // Pegue o tipo atual como um nó público da propriedade (int dados) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {retornar dados; } // Adicione o nó public void addNode (int dados) {if (this.Next == null) {this.Next = new Node (dados); } else {this.next.addnode (dados); }} // exclua o nó public void delnode (int dados) {if (this.Next! = Null) {if (this.next.getData () == data) {node tmp = this.next; this.Next = this.Next.Next; tmp = nulo; } else {this.Next.DelNode (Data); }}} // Expaida todos os nós public void printNode () {if (this.Next! = Null) {System.out.print (this.Next.getData () + ""); this.Next.printNode (); }} // Encontre se o nó existe public boolean findNode (int data) {if (this.next! = Null) {if (this.next.getData () == data) {return true; } else {return this.next.findnode (dados); }} retornar false; } // modifique o nó public boolean updateNode (int anticdata, int newData) {if (this.next! = Null) {if (this.next.getData () == OldData) {thisnext.setData (newdata); retornar true; } else {return this.Next.UpDatenode (OldData, newData); }} retornar false; } // Insira o nó public void insertNode (INCID INT, INT DATA) {currentIndex ++; if (index == currentIndex) {node newNode = new Node (dados); newNode.Next = this.Next; this.Next = newNode; } else {this.next.insertNode (index, dados); }}}}}O acima é o código completo para a operação básica da lista vinculada. A seguir, é apresentado um código de chamada para teste, o código é o seguinte:
classe pública linklist {public static void main (string [] args) {nodemanager nm = new NodeManager (); System.out.println ("Endereço da lista vinculada (adicione 5, 4, 3, 2, 1)"); nm.add (5); nm.add (4); nm.add (3); nm.add (2); nm.add (1); nm.print (); System.out.println ("Excluir da lista vinculada (delete 3)"); nm.delnode (3); nm.print (); System.out.println ("Procurando Lista Linked (Finding 1)"); System.out.println (nm.findnode (1)); System.out.println ("Lista de vinculação (encontre 10)"); System.out.println (nm.findnode (10)); System.out.println ("Lista de atualização (atualização 1 a 10)"); nm.updatenode (1, 10); nm.print (); System.out.println ("Inserir Lista (Inserir 20 na primeira posição)"); nm.insert (1, 20); nm.print (); System.out.println ("Inserir Lista (Insira 30 na primeira posição)"); nm.insert (1, 20); nm.print (); System.out.println ("Inserir Lista (Insira 30 na posição zero)"); nm.insert (0, 30); nm.print (); }}Compilar e executar o código, o resultado é o seguinte:
Eu usei muito conhecimento sobre estruturas de dados na classe de coleta em Java. Quando estiver em boas condições, aprenderei o código -fonte da classe de coleta Java. Vou trabalhar duro para ser um programador júnior!
Resumir
O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.