Contenido principal:
Simplemente sube el código, está tan desenfrenado ~~~
paquete pers.ty. $ 1101DataStructure; import java.util.hashtable;/*** @Author Administrator* Implementar las operaciones básicas de listas vinculadas únicas, agregando la deleción de nodos, clasificar, imprimir y calcular la longitud*/clase public myLinkedList {cabezal de nodo = null; // la función de los encabezados de la lista vinculada/** Datos insertados en la lista en los datos de la lista vinculada* Datos de inserción*/ public void addNode (int d) {nodo newnode = new node (d); if (head == null) {head = newnode; devolver; } Nodo tmp = head; while (tmp.next! = null) {tmp = tmp.next; } // Agregar nodo para finalizar tmp.next = newnode; }/*** @param índice: eliminar el nodo de índice* @return devuelve verdadero con éxito y devuelve falso si falló*/public boolean deletenode (int index) {if (index <1 || índice> longitud ()) {return false; // delete la posición del elemento irrazonable} // dele el primer elemento en la lista vinculada if (index == 1) {head. devolver verdadero; } int i = 1; Nodo prenode = head; Nodo curnode = prenode.next; while (curnode! = null) {if (i == index) {prenode.next = curnode.next; devolver verdadero; } prenode = curnode; curnode = curnode.next; i ++; } return verdadero; } / ** * @return Devuelve la longitud de la longitud de la lista vinculada * / public int longitud () {int longitud = 0; Nodo tmp = cabeza; while (tmp! = null) {longitud ++; tmp = tmp.next; } Longitud de retorno; } / *** ordene la lista vinculada* @return return the ordened encabezado nodo* / public nodo OrderList () {node nextNode = null; int temp = 0; Nodo curnode = head; while (curnode.next! = null) {nextNode = curnode.next; while (nextnode! = null) {if (curnode.data> nextNode.data) {temp = curnode.data; curnode.data = nextNode.data; nextNode.data = temp; } nextNode = nextNode.next; } curnode = curnode.next; } cabezal de retorno; } / *** Imprima todos los datos en la lista vinculada* / public void printList () {nodo tmp = head; while (tmp! = null) {system.out.print (tmp.data+""); tmp = tmp.next; } System.out.println (); } /*** La primera forma de eliminar los datos de la lista vinculada* atravesar la lista vinculada y almacenar los datos atravesados en una hashtable. Durante el proceso transversal, si el valor accedido actualmente existe en el hashtable*, puede eliminarlo*Ventajas: Complejidad de bajo tiempo: se requiere espacio de almacenamiento adicional para guardar los datos accedidos*/ public void DeletedUplecate1 () {Hashtable <Integer, Integer> table = New Hashtable <Integer, integer> ();); Nodo tmp = cabeza; Nodo pre = nulo; while (tmp! = null) {if (table.containskey (tmp.data)) pre.next = tmp.next; else {table.put (tmp.data, 1); pre = tmp; } tmp = tmp.next; }} / *** La segunda forma de eliminar los datos duplicados de la lista vinculada* Traversal de doble bucle* Las ventajas y las desventajas son obvias* / public void deletedupplecate2 () {nodo p = head; while (p! = null) {nodo q = p; while (q.next! = null) {if (p.data == q.next.data) {q.next = q.next.next; } else {q = q.next; }} p = p.next; }} /*** @param K: Encuentre el K-Th hasta el último nodo en la lista vinculada* @return Este nodo* establece dos punteros P1 y P2 para hacer P2 K más rápido que P1, y atravesar al mismo tiempo. Cuando P2 está vacío, P1 es el K-th hasta el último nodo*/ nodo público FindElem (cabezal de nodo, int k) {if (k <1 || k> this.length ()) return null; Nodo p1 = cabeza; Nodo p2 = cabeza; para (int i = 0; i <k-1; i ++) p2 = p2.next; while (p2.next! = null) {p2 = p2.next; p1 = p1.next; } return p1; } / *** Implemente la reversión de la lista vinculada* @param Head el nodo head de la lista vinculada* / public void reinscriptiteration (nodo head) {nodo preversedhead = head; Nodo pnode = head; Nodo pprev = nulo; while (pnode! = null) {node pnext = pnode.next; if (pnext == null) preversedhead = pnode; pnode.next = pprev; pprev = pnode; pnode = pnext; } this.head = Preversedhead; } / *** ENCONTRA una única lista vinculada desde la cola a la cabeza por recursivamente* @param head* / public void printListerSely (node head) {if (head! = Null) {printListerSely (head.next); System.out.print (head.data+""); }} / *** Consulta el nodo intermedio de una sola lista vinculada* Definir dos punteros, un paso a la vez y los otros dos pasos a la vez ...* @param head* @return Q es el nodo intermedio* / público de búsqueda público (cabezal de nodo) {nodo q = head; Nodo p = cabeza; while (p! = null && p.next! = null && p.next.next! = null) {q = q.next; p = p.next.next; } return Q; } / *** Elimine el nodo especificado sin conocer el puntero de la cabeza* El nodo de cola de la lista vinculada no se puede eliminar porque el siguiente puntero de su nodo predecesor no se puede configurar en vacío después de la eliminación* Otros nodos pueden intercambiar los valores de este nodo y su nodo sucesor, y luego eliminar el nodo sucesor* @param n* @return* / público boolean deletenodo (nodo (nodo del nodo) if (n == null || n.next == null) return false; int tmp = n.data; n.data = n.next.data; n.next.data = tmp; N.Next = N.Next.Next; devolver verdadero; } / *** Determine si dos listas vinculadas se cruzan* Si dos listas vinculadas se cruzan, debe haber el mismo nodo de cola, atravesar las dos listas vinculadas, registrar los nodos de la cola y ver si son el mismo* @param H1 nodo head de la lista de la lista 1* @param h2 nodo de la lista vinculada 2* @corral h2) {if (h1 == null || h2 == null) return false; Nodo cola1 = h1; while (tail1.next! = null) {tail1 = tail1.next; } Nodo cola2 = h2; while (tail2.next! = null) {tail2 = tail2.next; } return tail1 == Tail2; } / ** * Encuentre el primer nodo que se cruza * @param h1 * @param h2 * @return * / public nodo getFirstmeetNode (nodo h1, nodo h2) {if (h1 == null || h2 == null) return null; Nodo cola1 = h1; int len1 = 1; while (tail1.next! = null) {tail1 = tail1.next; Len1 ++; } Nodo cola2 = h2; int len2 = 1; while (tail2.next! = null) {tail2 = tail2.next; len2 ++; } if (tail1! = tail2) {return null; } Nodo t1 = h1; Nodo t2 = h2; // Encuentre la lista vinculada más larga y pase if (len1> len2) {int d = len1-Len2; while (d! = 0) {t1 = t1.next; d--; }} if (len1 <len2) {int d = len2-Len1; while (d! = 0) {t2 = t2.next; d--; }} while (t1! = t2) {t1 = t1.next; t2 = t2.next; } return t1; } public static void main (string [] args) {myLinkedList list = new MyLinkedList (); }}Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo sea de ayuda para el estudio o el trabajo de todos. ¡También espero apoyar a Wulin.com más!