Lista de enlaces ordenado:
Ordenar por valores clave. Al eliminar el encabezado de la cadena, se elimina el valor mínimo (/máximo). Al insertar, busque la posición de inserción.
Al insertar, debe comparar O (N), promedio O (N/2) y al eliminar los datos mínimos (/máximo) en el cabezal de la cadena, la eficiencia es O (1),
Si una aplicación requiere acceso frecuente (insertar/buscar/eliminar) a los elementos de datos más pequeños (/máximo), entonces las listas vinculadas ordenadas son una buena opción. Las colas prioritarias pueden usar listas vinculadas ordenadas para implementar la clasificación de inserción de las listas vinculadas ordenadas:
Para una matriz no ordenada, ordenelo con una lista vinculada ordenada, y el nivel de comparación de tiempo es O (n^2)
El nivel de tiempo de copia es o (2*n). Debido a que el número de copias es pequeño, los datos en la lista vinculada se mueven n veces por primera vez, y luego se copia de la lista vinculada a la matriz. N veces, cada vez que se inserta un nuevo enlace, no es necesario copiar los datos móviles, solo uno o dos enlaces deben cambiar el dominio del enlace.
importar java.util.arrays; import java.util.random; / *** Matrices de clasificación de inserción en una lista vinculada ordenada* @author Stone*/ public class LinkedListinSertSort <t extiende <T>> {enlace privado <t> primero; // Primer nodo public LinkedListInsertSort () {} public boolean isEtimty () {return primero == null; } public void sortList (t [] ary) {if (ary == null) {return; } // Insertar elementos de matriz en la lista vinculada y ordenarlos en una lista vinculada ordenada para (t data: ary) {insert (datos); } //} public void Insert (t data) {// Insertar en el encabezado de la cadena, ordene desde un enlace pequeño a grande <T> newlink = new Link <T> (datos); Enlace <T> Current = Primero, anterior = NULL; while (current! = null && data.compareto (current.data)> 0) {anterior = current; actual = current.next; } if (anterior == null) {primero = newlink; } else {anterior.next = newlink; } newlink.next = actual; } enlace público <t> deleteFirst () {// Eliminar el enlace del encabezado de cadena <T> temp = primero; primero = first.next; // Cambiar el primer nodo para devolver temp; } enlace público <t> find (t t) {link <t> find = primero; while (find! = null) {if (! find.data.equals (t)) {find = find.next; } else {break; }} return Find; } enlace público <t> delete (t t) {if (isEmpty ()) {return null; } else {if (first.data.equals (t)) {link <t> temp = primero; primero = first.next; // Cambiar el primer nodo a la siguiente temperatura de retorno del nodo; }} Enlace <t> p = primero; Enlace <t> q = primero; while (! P.data.equals (t)) {if (p.next == null) {// indica que el retorno nulo no se ha encontrado al final de la cadena; } else {q = p; P = P.Next; }} q.next = p.next; regreso p; } public void displayList () {// Travel System.out.println ("List (primero-> último):"); Enlace <t> corriente = primero; while (current! = null) {current.displaylink (); actual = current.next; }} public void displaylisterverse () {// enlace transversal inverso <t> p = primero, q = first.next, t; Mientras que (q! = null) {// se invierte el puntero, el orden de datos atravesado es hacia atrás t = q.next; // NO3 if (p == primero) {// Cuando es el encabezado original, el .next del encabezado debe estar vacío p.next = null; } Q.Next = P; // NO3 -> NO1 PUNTER REVERSE P = Q; // El inicio es inversa q = t; // NO3 Start} // En el if en el bucle anterior, primero. Después de invertir, P se asigna a First First = P; DisplayList (); } enlace de clase <T> {// Datos de punto t de enlace; // enlace de campo de datos <t> Siguiente; // Pointer posterior, enlace de dominio de cadena de nodo (t Data) {this.data = data; } void displayLink () {System.out.println ("Los datos son" + data.ToString ()); }} public static void main (string [] args) {LinkedListinSertsort <integer> list = new LinkedListinSertSort <Integer> (); Aleatorio aleatorio = new Random (); int len = 5; Entero [] ary = nuevo entero [len]; for (int i = 0; i <len; i ++) {ary [i] = random.nextint (1000); } System.out.println ("--------------"); System.out.println (Arrays.ToString (Ary)); System.out.println ("-----------------------------------------------------------); List.SortList (Ary); list.displayList ();}}
Imprimir
--- antes de clasificar ---- [595, 725, 310, 702, 444] --- Después de clasificar la lista vinculada ---- Lista (primero-> último): los datos son 310 Los datos son 444 los datos son 595 los datos son 702 los datos son 725 es 725 es 725
Inversión de la lista vinculada única:
public class SingLelinkedlisterverse {public static void main (string [] args) {nodo head = new node (0); Nodo temp = null; Nodo cur = nulo; para (int i = 1; i <= 10; i ++) {temp = new nodo (i); if (i == 1) {head.setNext (temp); } else {cur.setNext (temp); } cur = temp; } // 10.next = null; Nodo h = cabeza; while (h! = null) {system.out.print (h.getData () + "/t"); h = H.getNext (); } System.out.println (); // invertir 1 // h = node.reverse1 (cabeza); // while (h! = null) {// system.out.print (h.getData () + "/t"); // h = H.getNext (); //} // invertir 2 h = node.reverse1 (cabeza); while (h! = null) {system.out.print (h.getData () + "/t"); h = H.getNext (); }}}/** Cada nodo de una sola lista vinculada contiene atributos que apuntan al siguiente nodo*/class nodo {objeto data; // nodo de objeto de datos siguiente; // NODO NODO SIGUIENTE (Objeto D) {this.data = d; } Nodo (objeto d, nodo n) {this.data = d; this.next = n; } Public Object getData () {return data; } public void setData (datos de objeto) {this.data = data; } public nodo getNext () {return Next; } public void setNext (nodo siguiente) {this.next = next; } // El método 1 cabezal es restablecer el nodo estático reverso1 (cabezal de nodo) {nodo p = null; // La nueva cabeza después del nodo de inversión q = cabeza; // Resultado de rotación: 012,123,234, ...... 10 nulo nulo while (head.next! = Null) {p = head.next; // El primero es reemplazado por el segundo, y luego P representa el siguiente cabezal.next = P.Next; // El segundo es reemplazado por el tercero, y el siguiente que ya ha alcanzado la primera posición se convertirá en la primera, y la primera se convertirá en la primera; // El nuevo se reemplaza por el primero} return p; } // Método 2 La cabeza no restablece el nodo estático Reverse2 (cabezal de nodo) {// señala el puntero del nodo intermedio al nodo anterior, aún puede continuar atravesando el nodo de la lista vinculada P1 = cabeza, p2 = head.next, p3; // Resultado delantero, medio y posterior/rotación: 012, 123, 234, 345, 456 .... 9 10 nulo while (p2! = Null) {p3 = p2.next; P2.NEXT = P1; // señala hacia atrás y apunta hacia adelante P1 = P2; // 2, 3 se mueven hacia adelante P2 = P3; } head.next = null; // Head no ha cambiado. Cuando la salida alcanza 0, solicite 0.Next a 1 Devuelve P1; }}