Uma introdução ao uso de listas vinculadas em Java

Uma estrutura de dados usa diferentes métodos predefinidos para armazenar, recuperar e excluir dados que culminam na criação de programas eficientes. Uma lista vinculada é uma estrutura de dados popular, que consiste em uma lista de nós que estão conectados (ou vinculados).

Mas como você cria uma lista vinculada em Java? Vamos dar uma olhada.

Cada lista vinculada começa com um nó especial que geralmente é referido como "cabeça", que tem a responsabilidade de apontar para o início da lista o tempo todo. O cabeçalho é importante porque cada nó em uma lista encadeada não precisa seguir seu sucessor fisicamente (o que significa que um predecessor e um sucessor não precisam ser fisicamente adjacentes).

Como toda estrutura de dados, a lista vinculada facilita a criação, recuperação, inserção e destruição por meio de um conjunto de funções predefinidas que podem ser usadas por qualquer desenvolvedor.

Um programa Java projetado para criar e manipular listas vinculadas terá três seções distintas; a classe de nó, a classe de lista vinculada e o driver. Embora essas três seções possam ser combinadas em um arquivo, existe um princípio de design na ciência da computação conhecido como "separação de interesses" que todo desenvolvedor deve conhecer.

O princípio da separação de interesses determina que cada seção do código que trata de uma preocupação específica deve ser separada. Este princípio o ajudará a criar um código mais limpo (mais legível) e é ideal para criar estruturas de dados.

A primeira etapa na criação de uma lista vinculada em Java é criar uma classe de nó. Uma classe de nó deve ter dois atributos; um dos atributos representará a parte de dados do nó, enquanto o outro atributo representará a parte vinculada. Uma classe de nó também deve ter um construtor, getters e setters.

Relacionado: Aprenda a criar classes em Java

Os getters e setters permitirão que outras classes (como a classe de lista vinculada) acessem os vários nós dentro da lista vinculada.

Exemplo de classe de nó

Abaixo está um exemplo de classe de nó para você ter uma ideia do que queremos dizer:

public class Node {
private int Data;
Private Node NextNode;
//constructor
public Node () {
Dados = 0;
NextNode = null;
}
// getters e setters
public int getData () {
return Data;
}
public void setData (int data) {
Dados = dados;
}
public Node getNextNode () {
return NextNode;
}
public void setNextNode (Node nextNode) {
NextNode = nextNode;
}
}

Neste exemplo, o atributo de dados armazenará valores inteiros. Agora que você tem a classe de nó, é hora de passar para a lista vinculada.

Abaixo está um exemplo de uma lista vinculada em Java.

public class LinkedList {
Cabeça de Nó privada;
//constructor
public LinkedList () {
Head = null;
}
}

O código acima criará uma classe de lista vinculada, no entanto, sem suas várias operações, a classe pode ser vista como o equivalente a um shell vazio. A estrutura de dados da lista vinculada possui várias operações que podem ser usadas para preenchê-la:

• Insira na frente.
• Insira no meio.
• Insira na parte de trás.

Relacionado: Como construir estruturas de dados com classes JavaScript ES6

A coleção de lista vinculada de métodos de inserção é uma razão pela qual um desenvolvedor pode escolher usar esses dados estrutura sobre outra estrutura de dados, como pilhas (que só permite a inserção e exclusão a partir do topo).

Usando o método de inserção na frente

O método de inserção na frente, como o nome sugere, insere novos dados (ou novos nós) na frente da lista vinculada.

Exemplo de método de inserção na frente

Abaixo está um exemplo de como você inseriria novos dados no início da sua lista.

 // insira o nó na frente do método
public void insertAtFront (int key) {
// cria um novo nó usando a classe de nó
Temp do nó = novo nó ();
// verifique se o nó temporário foi criado com sucesso
// atribua os dados que foram fornecidos pelo usuário a ele
if (Temp! = null) {
Temp.setData (chave);
Temp.setNextNode (null);
// verifique se o cabeçalho da lista vinculada está vazio
// atribui o nó que acabou de ser criado à posição da cabeça
if (Head == null) {
Cabeça = Temp;
}
// se um nó já estiver na posição inicial
// adicione o novo nó a ele e defina-o como o principal
outro {
Temp.setNextNode (Cabeça);
Cabeça = Temp;
}
}
}

O insertAtFront método no exemplo acima permite que um usuário adicione novos nós a uma determinada lista encadeada.

Aplicando a Inserção no Exemplo Frontal

Abaixo está um exemplo de como você aplicaria a inserção na frente.

public class Driver {
// executa o programa
public static void main (String [] args) {
// cria uma nova lista vinculada chamada Lista
Lista LinkedList = novo LinkedList ();
// adicione cada valor à frente da lista vinculada como um novo nó
List.insertAtFront (10);
List.insertAtFront (8);
List.insertAtFront (6);
List.insertAtFront (4);
List.insertAtFront (2);
}
}

O Condutor class (que é o nome frequentemente atribuído à classe executável em Java), utiliza a classe LinkedList para criar uma lista vinculada de cinco números pares. Olhando para o código acima, deve ser fácil ver que o número "2" está na posição inicial na lista vinculada. Mas como você pode confirmar isso?

Usando o método de exibição de todos os nós

O método de exibição de todos os nós é um método de lista vinculada essencial. Sem ele, um desenvolvedor não será capaz de ver os nós em uma lista vinculada. Ele percorre a lista encadeada (começando pelo cabeçalho) imprimindo os dados armazenados em cada nó que forma a lista.

Exemplo de método de exibição de todos os nós

Abaixo está um exemplo de uso do método de exibição de todas as notas em Java.

// exibe o método de todos os nós
public void displayAllNodes () {
// criar uma nova chamada de nó Temp e atribuí-la ao cabeçalho da lista vinculada
// se o cabeçalho tiver um valor nulo, a lista vinculada está vazia
Temp do nó = cabeça;
if (Head == null) {
System.out.println ("A lista está vazia.");
Retorna;
}
System.out.println ("A lista:");
enquanto (Temp! = nulo) {
// imprime os dados em cada nó para o console (começando pela cabeça)
System.out.print (Temp.getData () + "");
Temp = Temp.getNextNode ();
} 
}

Agora que o displayAllNodes método foi adicionado ao LinkedList classe, você pode ver a lista vinculada adicionando uma única linha de código à classe do driver.

Usando o Exemplo do Método Exibir Todos os Nós

Abaixo, você verá como usaria o método de exibição de todos os nós.

// imprime os nós em uma lista vinculada
List.displayAllNodes (); 

Executar a linha de código acima produzirá a seguinte saída no console:

A lista:

2 4 6 8 10

Usando o método Find Node

Haverá casos em que um usuário desejará encontrar um nó específico em uma lista vinculada.

Por exemplo, não seria prático para um banco que tem milhões de clientes imprimir todos os clientes em seu banco de dados quando eles só precisam ver os detalhes de um cliente específico.

Portanto, em vez de usar o displayAllNodes método, um método mais eficiente é encontrar o único nó que contém os dados necessários. É por isso que a busca por um método de nó único é importante na estrutura de dados da lista vinculada.

Exemplo de Método de Localização de Nó

Abaixo está um exemplo de uso do método find node.

// pesquisa por um único nó usando uma chave
public boolean findNode (int key) {
// crie um novo nó e coloque-o no topo da lista vinculada
Temp do nó = cabeça;
// enquanto o nó atual não está vazio
// verifique se seus dados correspondem à chave fornecida pelo usuário
enquanto (Temp! = nulo) {
if (Temp.getData () == key) {
System.out.println ("O nó está na lista"); 
return true;
}
// mover para o próximo nó
Temp = Temp.getNextNode ();
}
// se a chave não foi encontrada na lista vinculada
System.out.println ("O nó não está na lista"); 
retorna falso;
}

Com o displayAllNodes método, você confirmou que o LinkedList contém 5 números pares de 2 a 10. O findNode O exemplo acima pode confirmar se um desses números pares é o numeral 4 simplesmente chamando o método na classe do driver e fornecendo o número como um parâmetro.

Usando o Exemplo do Método Find Node

Abaixo está um exemplo de como você usaria o método find node na prática.

// verifique se um nó está na lista vinculada
List.findNode (4);

O código acima produzirá a seguinte saída no console:

O nó está na lista

Usando o Método Excluir um Nó

Usando o mesmo exemplo de banco acima, um cliente no banco de dados do banco pode desejar encerrar sua conta. É aqui que o método de exclusão de um nó será útil. É o método de lista vinculada mais complexo.

O método Delete a Node procura um determinado nó, exclui esse nó e vincula o nó anterior àquele que segue o nó que foi excluído.

Excluir um Exemplo de Método de Nó

Abaixo está um exemplo do método de exclusão de um nó.

public void findAndDelete (int key) { 
Temp do nó = cabeça; 
Nó prev = nulo; 
// verifique se o nó principal contém os dados 
// e excluí-lo 
if (Temp! = null && Temp.getData () == key) { 
Cabeça = Temp.getNextNode (); 
Retorna; 
} 
// pesquisa os outros nós da lista 
// e excluí-lo 
enquanto (Temp! = nulo) { 
if (Temp.getNextNode (). getData () == chave) { 
prev = Temp.getNextNode (). getNextNode (); 
Temp.setNextNode (anterior); 
Retorna; 
} 
Temp = Temp.getNextNode (); 
} 
} 

Usando o Exemplo de Método de Exclusão de Nó

Abaixo está um exemplo de como usar o método de exclusão de um nó na prática.

// exclua o nó que contém os dados 4
List.findAndDelete (4);
// imprime todos os nós na lista vinculada
List.displayAllNodes ();

Usar as duas linhas de código acima na classe Driver pré-existente produzirá a seguinte saída no console:

A lista:
2 6 8 10

Se você chegou ao final deste artigo tutorial, terá aprendido:

• Como criar uma classe de nó.
• Como criar uma classe de lista vinculada.
• Como preencher uma classe de lista vinculada com seus métodos predefinidos.
• Como criar uma classe de driver e usar os diferentes métodos de lista vinculada para obter o resultado desejado.

Uma lista vinculada é apenas uma das muitas estruturas de dados que você pode usar para armazenar, recuperar e excluir dados. Já que você tem tudo de que precisa para começar, por que não experimentar esses exemplos em Java?

Como criar e realizar operações em matrizes em Java

Aprendendo Java? Deixe que os arrays gerenciem seus dados com facilidade.

Leia a seguir

Sobre o autor