Directorio de artículos
Tabla de contenido
1. ¿Qué es una lista enlazada?
2. Clasificación e implementación de listas enlazadas.
2. Cree una lista enlazada individualmente
2. Elimine el primer nodo cuyo valor de nodo sea clave.
3. Insertar nodo (en la posición especificada)
4. Obtenga la longitud de la lista vinculada.
prefacio
Hola a todos, este blog les dirá qué es una lista enlazada y el proceso de implementación de una lista enlazada individualmente.
1. ¿Qué es una lista enlazada?
Al explicar qué es una lista vinculada, primero permítame explicarle la clasificación general de la lista lineal y la lista de secuencia.
Mesa lineal:
Una lista lineal es una secuencia finita de n elementos de datos con las mismas características. Una tabla lineal es una estructura de datos muy utilizada en la práctica. Tablas lineales comunes: lista enlazada, pila, cola ... Una tabla lineal es lógicamente una estructura lineal, es decir, una línea recta continua. Sin embargo, la estructura física no es necesariamente continua. Cuando las tablas lineales se almacenan físicamente, generalmente se almacenan en forma de matrices y estructuras vinculadas.
Se puede ver que la lista vinculada no es continua en la memoria, sino lógicamente continua: los nodos de la lista vinculada se almacenan en la memoria como una ranura.
Tabla de secuencia:
Una tabla de secuencia es una estructura lineal que utiliza una unidad de almacenamiento con una dirección física continua para almacenar elementos de datos en secuencia. Generalmente se utiliza almacenamiento en matriz. Agregue, elimine, verifique y modifique datos en la matriz.
2. Clasificación e implementación de listas enlazadas.
Clasificación:
Las listas vinculadas se pueden dividir en dos categorías según si contienen un nodo principal, y también se pueden dividir en dos categorías según si están en bucle.
Hay relativamente poca diferencia entre bucles y no bucles. A continuación analizaremos si incluir el nodo principal.
Pregunta 1: ¿Cuál es la diferencia entre una lista vinculada con un nodo principal y una lista vinculada sin un nodo principal?
El primer nodo de la lista vinculada con el nodo principal no almacena datos, por lo que es relativamente fácil de implementar.
El primer nodo sin el nodo principal es el nodo de datos, que es más difícil de implementar que el nodo principal y es el foco de preguntas y entrevistas.
A continuación, lo llevaré a implementar la lista enlazada individualmente más clásica: una lista enlazada acíclica sin un nodo principal.
lograr:
Análisis de ideas:
1. Cree la clase de nodo Nodo para representar los nodos en la lista vinculada.
2. Cree una lista enlazada individualmente SingleList
3. Implementar métodos para agregar, eliminar, verificar...
1. Crea una clase de nodo
Pensemos en la información que debería existir en la clase de nodo.
La información registrada en los nodos en el trabajo y la vida diaria es diversa, por simplicidad usaremos la más simple, es decir, el nodo solo contiene
val y el puntero al siguiente nodo siguiente
clase Nodo{
public int val;
Nodo público siguiente;
Nodo público (int val) {
this.val = val;
}
}
2. Cree una lista enlazada individualmente
Con la clase de nodo, podemos combinar nodos uno por uno en una lista enlazada lógicamente continua.
Entonces, ¿qué debería existir en una lista enlazada individualmente?
En primer lugar, debe haber un nodo principal; de lo contrario, no podemos saber dónde comienza la lista vinculada y no podemos pasar la lista vinculada como parámetro.
En segundo lugar, debería haber un método de construcción; de lo contrario, no tendría sentido escribir una lista vinculada de este tipo.
También hay algunos métodos. Se proporciona el código básico. Implementemos los métodos uno por uno.
clase pública SingleListDemo {
cabecera de nodo privado;
public SingleListDemo(){
}
}
clase Nodo{
public int val;
Nodo público siguiente;
Nodo público (int val) {
this.val = val;
}
}
1.addTail (aumento de cola)
public void addTail(int val) { Nodo nuevoNodo = nuevo Nodo(val); if (cabeza == nulo) { cabeza = nuevoNodo; devolver; } Nodo cur = cabeza; mientras (cur.siguiente! = nulo) { cur = cur.siguiente; } cur.next = nuevoNodo; }
Aquí podemos extender la situación de insertar nodos en la cabecera, es decir, apuntar el siguiente puntero del nuevo nodo al nodo cabecera y cambiar la punta del nodo cabecera a un nuevo nodo.
2. Elimine el primer nodo cuyo valor de nodo sea clave.
// Eliminar el primer nodo cuyo valor de datos es clave
public void DeleteKey(int key) {
// Determinar si la lista vinculada está vacía
if (head == null) {
System.out.println("La lista vinculada está vacía") ;
return;
}
// Determina si el primer nodo es el nodo que se va a eliminar
if (head.val == key) {
HeadDelete();
return;
}
Nodo cur = head;
while (cur.next! = null) {
if ( cur.next.val == clave) {
cur.next = cur.next.next;
return;
}
cur = cur.next;
}
}
Extensión: elimine todos los nodos cuyo valor sea clave, se requiere que la complejidad del tiempo no exceda O (n)
// El método uno recorre
public void Delete(int Data) {
if (head == null) {
return;
}
while (head.val == Data) {
head = head.next;
if (head == null) {
return ;
}
}
Nodo cur = head;// Definir un nodo temporal en lugar del nodo principal para recorrer la lista vinculada y eliminar elementos
while (true) {
if (cur.next == null) {
return;
}
if (cur.next .val == Datos ) {
System.out.println("¡Eliminación exitosa!");
cur.next = cur.next.next;
continuar;
}
cur = cur.next;
}
}
// Método 2: puntero doble
public void Eliminar2 (int Datos) {
if (head == null) {
return;
}
Nodo pre = cabeza;
Nodo cur = head.next;
while (cur != null) {
if (cur.val == Datos) {
pre.next = cur.next;
} más {
pre = cur;
}
cur = cur.siguiente;
}
if (head.val == Datos) {
head = head.next;
}
}
3. Insertar nodo (en la posición especificada)
// Inserta un nodo en la posición especificada, el primer nodo es el subíndice 0
public void InsertAny(int index, int val) {
// Determina si el subíndice de la lista vinculada es legal
if (index < 0 && index > getSize() ) {
System .out.println("¡Subíndice no válido!");
return;
}
if (index == 0) {
HeadAdd(val);
return;
}
Nodo nodo = nuevo Nodo(val);
Nodo cur = cabeza;
// Recorrer la lista enlazada encuentra el elemento con índice-1
mientras (índice > 1) {//index-1
índice--;
cur = cur.next;
}
node.next = cur.next;
cur.next = node;
}
4. Obtenga la longitud de la lista vinculada.
public int getSize() {
Nodo nodo = cabeza;
tamaño entero = 0;
while (nodo! = nulo) {
nodo = nodo.siguiente;
tamaño++;
}
tamaño de retorno;
}
Los anteriores son algunos de los métodos más importantes. Nos vemos en el próximo número.
Resumir
Practique más preguntas, ¡la lista vinculada es el foco de las preguntas del examen escrito en la entrevista!