La copia del código es la siguiente:
/**
* Lista vinculada de ida
*
*/
clase pública nodelist <E> {
Nodo de clase estática privada <E> {// Clase de nodo
E datos;
Nodo <E> Siguiente;
Nodo (e e) {
this.data = e;
this.next = null;
}
}
Nodo privado <E> Cabeza;
nodo privado <E> último;
Nodo privado <E> OTRO = NULL;
Longitud privada int = 0;
/**
* Método de construcción no parámetro
*/
public nodelist () {
// El nodo predeterminado está vacío
this.head = nuevo nodo <E> (nulo);
}
/**
* Crear un nodo durante la inicialización
*
* @param datos
* datos
*/
Public nodelist (e datos) {
this.head = nuevo nodo <E> (datos);
this.last = head;
longitud ++;
}
/**
* Agregar un nodo (método de inserción de cola)
*
* @param datos
* datos
*/
public void add (e datos) {
if (isEmpty ()) {
head = nuevo nodo <E> (datos);
último = cabeza;
longitud ++;
} demás {
Nodo <E> newnode = nuevo nodo <E> (datos);
last.next = newnode;
Último = Newnode;
}
}
/**
* Obtenga los datos en el índice (el error de entrada del índice arroja una excepción fuera de los límites)
* @Param ÍNDICE ÍNDICE
* @Datos de retornos en el índice
*/
public e get (int index) {
if (index <0 || índice> longitud) {
tirar el nuevo índiceutoutOfBoundSexception ("índice:"+índice);
}
otro = cabeza;
para (int i = 0; i <index; i ++) {
otro = otro.next;
}
devolver otros. Data;
}
/**
* Nuevo valor reemplaza el valor antiguo
* @return el éxito es verdadero, no encontrado como falso
*/
set público booleano (e OldValue, E NewValue) {
otro = cabeza;
while (otro! = null) {
if (otro.data.equals (OldValue)) {
otro.data = newValue;
devolver verdadero;
}
otro = otro.next;
}
devolver falso;
}
/**
* Inserte un elemento después de especificar el elemento
*
* @param datos
* Elemento especificado
* @param insertData
* Elementos que deben insertarse
* @return false es elemento no encontrado, verdadero es la inserción exitosa
*/
public boolean add (e datos, e insertados) {
otro = cabeza;
while (otro! = null) {
if (otro.data.equals (data)) {
Nodo <E> newnode = nuevo nodo <E> (insertData);
Nodo <E> temp = other.next;
newnode.next = temp;
otro.next = newnode;
longitud ++;
devolver verdadero;
}
otro = otro.next;
}
devolver falso;
}
/**
* Si este elemento está incluido en la lista vinculada
* @return incluido como verdadero, no falso
*/
Public Boolean contiene (e datos) {
otro = cabeza;
while (otro! = null) {
if (otro.data.equals (data)) {
devolver verdadero;
}
otro = otro.next;
}
devolver falso;
}
/**
* Eliminar el elemento especificado
* @param elementos de datos que deben eliminarse
* @return no existe y es cierto para el éxito
*/
Public Boolean Retember (E Data) {
otro = cabeza;
Nodo <E> temp = head; // Variable temporal, utilizado para guardar el nodo anterior
while (otro! = null) {
if (otro.data.equals (data)) {
temp.next = other.next;
longitud--;
devolver verdadero;
}
temp = otro;
otro = otro.next;
}
devolver falso;
}
/**
* Determinar si la lista vinculada está vacía
*
* @return vacío es verdadero, no vacío es falso
*/
Public boolean isEtimty () {
Longitud de retorno == 0;
}
/**
* Borrar la lista de enlaces
*/
public void clear () {
this.head = nulo;
this.length = 0;
}
/**
* Salir todos los nodos
*/
public void printLink () {
if (isEmpty ()) {
System.out.println ("Lista vinculada vacía");
}demás{
otro = cabeza;
while (otro! = null) {
System.out.print (Other.Data);
otro = otro.next;
}
System.out.println ();
}
}
}