A cópia do código é a seguinte:
/**
* Lista vinculada unidirecional
*
*/
classe pública nodelist <e> {
classe estática privada nó <E> {// classe de nó
E dados;
Nó <E> Em seguida;
Nó (e e) {
this.data = e;
this.Next = null;
}
}
nó privado <e> cabeça; // nó de cabeçalho da lista vinculada
nó privado <e> Último; // O nó da cauda da lista vinculada
nó privado <e> outro = nulo;
Private int comprimento = 0;
/**
* Método de construção não parâmetro
*/
public NodeList () {
// O nó padrão está vazio
this.head = novo nó <E> (nulo);
}
/**
* Crie um nó durante a inicialização
*
* Dados @param
* dados
*/
public NodeList (e dados e) {
this.head = novo nó <E> (dados);
this.last = head;
comprimento ++;
}
/**
* Adicione um nó (método de inserção da cauda)
*
* Dados @param
* dados
*/
public void add (e dados e) {
if (isEmpty ()) {
cabeça = novo nó <E> (dados);
último = cabeça;
comprimento ++;
} outro {
Nó <E> newNode = novo nó <E> (dados);
last.Next = newNode;
last = newNode;
}
}
/**
* Obtenha os dados no índice (o erro de entrada do índice lança uma exceção fora dos limites)
* Índice de @param Índice
* @return dados no índice
*/
public e get (int index) {
if (índice <0 || índice> comprimento) {
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 (e OldValue, e newvalue) {
outro = cabeça;
while (outro! = null) {
if (other.data.equals (OldValue)) {
outro.data = newValue;
retornar true;
}
outro = outro.next;
}
retornar falso;
}
/**
* Insira um elemento depois de especificar o elemento
*
* Dados @param
* Elemento especificado
* @param insertData
* Elementos que precisam ser inseridos
* @return false é elemento não encontrado, true é a inserção bem -sucedida
*/
public boolean add (e dados, e insertdata) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
Nó <E> newNode = novo nó <E> (insertData);
Nó <E> temp = outro.next;
newNode.Next = temp;
outro.next = newNode;
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 (e dados) {
outro = cabeça;
while (outro! = null) {
if (outros.data.equals (dados)) {
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 Remover (e dados e) {
outro = cabeça;
Nó <E> temp = head; // variável temporária, usada para salvar o nó anterior
while (outro! = null) {
if (outros.data.equals (dados)) {
temp.next = outro.next;
comprimento--;
retornar true;
}
temp = outro;
outro = outro.next;
}
retornar falso;
}
/**
* Determine se a lista vinculada está vazia
*
* @return vazio é verdadeiro, não vazio é falso
*/
public boolean isEmpty () {
comprimento de retorno == 0;
}
/**
* Limpe a lista de links
*/
public void clear () {
this.head = null;
this.length = 0;
}
/**
* Saída de todos os nós
*/
public void printlink () {
if (isEmpty ()) {
System.out.println ("Lista vinculada vazia");
}outro{
outro = cabeça;
while (outro! = null) {
System.out.print (outros.data);
outro = outro.next;
}
System.out.println ();
}
}
}