Lista Java duplamente vinculada

Uma lista vinculada é um tipo de estrutura de dados padrão que consiste em vários nós adjacentes. Todo nó protege as informações e o endereço do cluster depois que está em. Uma lista duplamente vinculada é uma variação da lista vinculada. O conteúdo e o ponteiro adicional, conhecido como ponteiro anterior, que estão presentes na lista única vinculada também estão presentes em uma lista duplamente vinculada. Em outras palavras, a lista duplamente vinculada pode oferecer a você a oportunidade de se mover em ambas as direções, eu.e. para trás e para frente, enquanto a lista de ligações individuais só se move em direção à direção para a frente. Neste guia, vamos discutir como podemos criar uma lista de ligações duplas na linguagem java.

Exemplo 01:

Introdução ao primeiro exemplo Java deste artigo, veremos como uma lista duplamente vinculada pode ser criada na programação Java em alguns segundos usando algumas linhas de código. O código fornecido abaixo pode ser executado especialmente no Eclipse IDE. Este código Java não precisa de nenhum pacote de java para ser importado antes do início de uma nova classe.

Certifique -se de nomear a classe usada no código da mesma forma que o nome do seu arquivo java i.e. "teste". A classe de teste principal contém muitas funções definidas pelo usuário, juntamente com sua estrutura de classe infantil chamada "Node" que está sendo utilizada para criar um nó. A classe do nó contém a declaração de dados inteiros "D", "P" anterior e o próximo nó consecutivo "n" para que um nó atual seja criado. Esta classe "nó" também contém a função do construtor "Nó" para definir os dados para um nó atualmente criado. O nó da cabeça "H" e o nó da cauda "T" foram definidos como nulos. A partir da função Main () deste programa, a lista vinculada “L” foi criada usando a técnica de criação de objetos para a principal classe “Teste”. A chamada de função para a função "add" da classe "teste" foi executada usando o objeto Lista duplamente vinculado "L" para adicionar 5 valores de dados à lista dupla vinculada um após o outro.

Certifique -se de adicionar os dados inteiros à lista duplamente vinculada. Quando a função "add" recebe uma chamada com o valor "d" de dados, ele executará a função Add que começa com a criação de um novo nó "newn". Aí vem a declaração if-else para verificar se o nó está vazio ou não. Se for "nulo", o nó da cabeça e da cauda se tornará um novo nó, enquanto o nó anterior e o próximo nó de uma cabeça será definido como "nulo" por enquanto. O nó anterior se tornará cabeça e o próximo nó se tornará uma cauda. Caso contrário, a parte else será executada se a cabeça não for "nula". Aqui, os nós serão trocados. O próximo nó de uma cauda se tornará um novo nó e o nó anterior de um novo nó "newn" se tornará uma cauda.

Ao mesmo tempo, o nó da cauda se tornará um novo nó e a próxima cauda será definida como nula. Quando a função show () for chamada, ela executará a função "show" abaixo do final da função add (). Aqui, definiremos o nó atual como o nó "cabeça". Se ainda assim, o nó da cabeça é nulo, exibirá que a lista vinculada está vazia. Caso contrário, continuará verificar se o nó atual é nulo ou não, além de exibir o valor dos dados "d" neste nó atual em particular.

No final, o texto do nó atual se tornará o nó atual para a próxima chamada de função. Aqui, nossa função principal () foi concluída após adicionar e exibir os dados de nós da lista duplamente vinculados. Vamos apenas copiar, colar e executar este código Java para ver sua saída.

teste de pacote;
Teste de classe pública
classe nó
int d;
Nó p;
Nó n;
nó público (int d)
esse.d = d;

Nó h, t = nulo;
public void add (int d)
Nó newn = novo nó (d);
if (h == null)
h = t = newn;
h.p = nulo;
t.n = nulo;

outro
t.n = newn;
NEWN.p = t;
t = newn;
t.n = nulo;

public void show ()
Nó c = h;
if (h == null)
Sistema.fora.println ("Lista está vazia");
retornar;

Sistema.fora.println ("Lista Linked Double:");
enquanto (c != null)
Sistema.fora.impressão (c.d + "");
c = c.n;

public static void main (string [] args)
teste l = novo teste ();
eu.Add (11);
eu.Add (62);
eu.Add (23);
eu.Add (14);
eu.Add (45);
eu.Mostrar();

Após a execução deste código no Eclipse IDE, todos os 5 valores de dados na lista duplamente vinculada “L” foram exibidos na mesma ordem. Nós os adicionamos sem mudança na ordem. O ponto a ser observado é que, se não tivéssemos usado a função "Add" para adicionar dados a uma lista duplamente vinculada, pode ter exibido que a lista duplamente vinculada está atualmente vazia.

Exemplo 02:

Vamos dar uma olhada em outro exemplo de java. Vamos exibir não apenas uma maneira de criar um novo nó, mas também uma maneira de excluir os nós dos nós de início e final e mover -se em ambas as direções. A partir da função principal deste código, criamos um objeto de lista duplamente vinculado "L" para tipos inteiros e declaramos uma cabeça, cauda e tamanho para "0" para a lista vinculada. A função 2 chama para a função "addf" que levará a uma criação temporária de nó "temperatura". Se a cabeça não for nula, definiremos a cabeça anterior como um nó "temp". Caso contrário, a cabeça se tornará "temp" e se a cauda for nula, ela se tornará um nó "temp".

Na chamada de função para a função "addl", levará a adicionar um nó de elemento de dados à esquerda do nó atual usando da maneira semelhante que adotamos para adicionar um nó no lado direito. As condições usadas em suas declarações "se" serão revertidas desta vez. A chamada de função “movefor” leva você a avançar em uma lista duplamente vinculada. Depois de avançar, tentamos a chamada de função para as funções "rmvf" e "rmvl" para remover os nós de dados recém -adicionados no primeiro e no último da lista duplamente vinculada.

teste de pacote;
importar java.util.NosuchElementException;
Teste de classe pública
Nó privado H;
nó privado t;
Tamanho privado int;
public test ()
tamanho = 0;

Nó da classe privada
T d;
Nó n;
Nó p;
Public Node (T D, Nó N, Nó P)
esse.d = d;
esse.n = n;
esse.p = p;

public int size ()
tamanho de retorno;
public boolean isEmpty ()
tamanho de retorno == 0;
public void addf (t d)
Nó temp = novo nó (d, h, nulo);
se (h != null)
h.p = temp;

h = temp;
if (t == null)
t = temp;

tamanho ++;
Sistema.fora.println ("Adicionando d:"+d);

public void addl (t d)
Nó temp = novo nó (d, null, t);
se (t != null)
t.n = temp;

t = temp;
if (h == null)
h = temp;

tamanho ++;
Sistema.fora.println ("Adicionando dados:"+d);

public void movefor ()
Sistema.fora.println ("iterando para a frente.");
Nó temp = h;
enquanto (temp != null)
Sistema.fora.println (temp.d);
temp = temp.n;

public void moveback ()
Sistema.fora.println ("iterando a palavra de fundo.");
Nó temp = t;
enquanto (temp != null)
Sistema.fora.println (temp.d);
temp = temp.p;

public t rmvf ()
if (size == 0) lança novos nosuchElementException ();
Nó temp = h;
h = h.n;
h.p = nulo;
tamanho--;
Sistema.fora.println ("Excluído d:"+temp.d);
Retornar Temp.d;

public t rmvl ()
if (size == 0) lança novos nosuchElementException ();
Nó temp = t;
t = t.p;
t.n = nulo;
tamanho--;
Sistema.fora.println ("Dados excluídos:"+Temp.d);
Retornar Temp.d;

public static void main (string args [])
tentar
teste l = novo teste ();
eu.Addf (2);
eu.Addf (26);
eu.Addl (11);
eu.Movefor ();
eu.Rmvf ();
eu.Rmvl ();
eu.Moveback ();
catch (exceção er)
er.printStackTrace ();

Após a execução, 2 nós no início e 2 nós no endpoint foram adicionados ao avançar todos os dados do nó foram exibidos. Dois nós foram excluídos e os dados do último nó foram exibidos depois de mover para trás.

Conclusão

O uso de uma lista duplamente vinculada é muito comum entre os programadores Java para se mover e trabalhar em ambas as direções. Junto com isso, os exemplos Java são a principal parte importante deste artigo para discutir uma maneira de criar uma lista duplamente vinculada usando os dados, anteriores, atuais e próximos nós, etc.