A cópia do código é a seguinte:
/**
* Implementação de listas vinculadas de mão dupla
* @Author Skip
* @version 1.0
*/
classe pública DoubleNodelist <T> {
// classe de nó
classe estática privada nó <T> {
Nó <T> Perv; // Nó frontal
Nó <T> Próximo; // Último nó
T dados; // dados
nó público (t t) {
this.data = t;
}
}
nó privado <t> cabeça; // nó de cabeça
nó privado <T> Último; // Nó da cauda
Nó privado <T> Outros; // Operação temporária para armazenamento de nós de espera
Private int comprimento; // Comprimento da lista vinculada
/**
* Estrutura não glicópica
*/
public DoubleNodelist () {
cabeça = novo nó <T> (nulo);
último = cabeça;
comprimento = 0;
}
/**
* Crie um nó durante a inicialização
* Dados @param
*/
public DoubleNodelist (t Data) {
cabeça = novo nó <T> (dados);
último = cabeça;
comprimento = 1;
}
/**
* Adicione um nó
* @param dados adicionados dados
*/
public void add (t Data) {
if (isEmpty ()) {
cabeça = novo nó <T> (dados);
último = cabeça;
comprimento ++;
}outro{
// Método de inserção da cauda
outro = novo nó <T> (dados);
outro.perv = last;
last.Next = outro;
último = outro;
comprimento ++;
}
}
/**
* Insira um nó após especificar dados
* @param dados especificados dados
* @param insertdata dados inseridos
* @return retorna true se a inserção for bem -sucedida, false se a inserção não tiver êxito.
*/
public boolean addafert (dados t, t insertData) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
Nó <T> t = novo nó <T> (insertData);
t.perv = outro;
t.Next = Other.Next;
outro.next = t;
// julga se deve adicionar nós após o último nó
if (t.next == null) {
último = t;
}
comprimento ++;
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Insira um nó antes de especificar dados
* @param dados especificados dados
* @param insertdata dados inseridos
* @return retorna true se a inserção for bem -sucedida, false se a inserção não tiver êxito.
*/
public boolean addBefore (t dados t, t insertData) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
Nó <T> t = novo nó <T> (insertData);
t.perv = outros.perv;
t.Next = outro;
outro.perv.Next = t;
comprimento ++;
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Obtenha os dados no índice
* Índice de @param Índice
* Dados @return
*/
public t get (int index) {
if (índice> comprimento || índice <0) {
lançar novo indexOutOfBoundSexception ("índice:"+índice);
}
outro = cabeça;
for (int i = 0; i <index; i ++) {
outro = outro.next;
}
retornar outro.data;
}
/**
* Novo valor substitui o valor antigo
* @return O sucesso é verdadeiro, não encontrado como falso
*/
conjunto público booleano (T OldValue, T NewValue) {
outro = cabeça;
while (outro! = null) {
if (other.data.equals (OldValue)) {
outro.data = newValue;
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Remova o elemento especificado
* elementos de dados @param que precisam ser removidos
* @return não existe e é verdadeiro para o sucesso
*/
Public boolean Remove (t Data) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
outros.perv.Next = Other.Next;
comprimento--;
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Se esse elemento está incluído na lista vinculada
* @return incluído como verdadeiro, não falso
*/
Public boolean contém (t dados t) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Obtenha os dados do último nó
* @return dados do último nó
*/
public t getLast () {
retornar por último.data;
}
/**
* Obtenha os dados do primeiro nó
* @return os dados do primeiro nó
*/
public t getfirst () {
Return head.data;
}
/**
* Obtenha o comprimento da lista vinculada
* @return comprimento
*/
public int getSize () {
comprimento de retorno;
}
/**
* É uma tabela de link vazia
* @RETURN A lista vazia é verdadeira e a lista não vazia é falsa
*/
public boolean isEmpty () {
comprimento de retorno == 0;
}
/**
* Limpe a lista de links
*/
public void clear () {
cabeça = nulo;
comprimento = 0;
}
/**
* Saída de todos os nós na lista vinculada
*/
public void printList () {
if (isEmpty ()) {
System.out.println ("Lista vinculada vazia");
}outro{
outro = cabeça;
for (int i = 0; i <comprimento; i ++) {
System.out.print (outros.data+"");
outro = outro.next;
}
System.out.println ();
}
}
}