1. Introducción básica de la lista vinculada
Primero, la lista vinculada almacena datos en forma de nodos. Cada nodo contiene un campo de datos (datos) y un campo de nodo (siguiente). La ubicación de almacenamiento de cada nodo de la lista vinculada en la computadora es discontinua y aleatoria . La inserción y eliminación son mejores, y la eficacia de la búsqueda de datos no es demasiado buena (debido a que la lista vinculada no puede leer datos aleatoriamente como datos estáticos, debe encontrar los datos correspondientes en orden).
2. Lista de enlaces unidireccionales
2.1. ¿Qué es una lista vinculada individualmente?
Una lista unidireccional es como un tren. Todos los nodos están conectados en una fila y la dirección del puntero es la misma. Es decir, además de almacenar los datos originales, cada nodo en la lista también almacena la dirección de almacenamiento del siguiente nodo. Como se muestra a continuación:
Implementación de código de clase de nodo
clase SingleNode {
public Object object; // Datos de nodo
public SingleNode next; // Apunte al siguiente nodo
public SingleNode () {
}
public SingleNode (Object object, SingleNode next) {
this.object = object;
this.next = next;
}
}
2.2. Implementación de la lista unidireccional de la lista (agregar, eliminar, modificar, ver) datos
/ **
* Implementación de lista enlazada individual
* /
public class SingleLinkList {
private SingleNode first; // Definir el nodo principal
private SingleNode last; // Definir el
tamaño del nodo tail private int; // Definir el número de nodos en la lista enlazada
/ **
* Juzgar la lista enlazada Si está vacío
* @return
* /
public boolean isEmpty () {
return first == null;
}
/ **
* Agregar elementos al principio y al final de la lista vinculada
* Análisis de ideas: cuando la lista vinculada está vacía, es equivalente a la lista vinculada Agregue datos al encabezado, así que asigne el nodo recién agregado al nodo principal (nodo de cola),
* Cuando la lista vinculada no está vacía, es equivalente a agregar datos al final de la lista vinculada, en este momento estamos apuntando el puntero de cola al nuevo El nodo agregado (es decir, last.next = node), y luego asigne el nodo recién agregado al
* último nodo (ie last = node)
* /
public void add (Object object) {
SingleNode node = new SingleNode (objeto, nulo);
if (isEmpty ()) {
first = node;
} else {
last.next = node;
}
last = node;
size ++;
}
/ **
* Agregar elementos al nodo especificado
* Análisis de ideas: primero necesitamos juzgar si la posición agregada Cumpla la condición (index> 0 && index <size), luego necesitamos encontrar el elemento en la posición de índice especificada y el elemento en su posición anterior, así que use
* dos punteros para registrar el elemento en la posición de índice y el elemento en su posición anterior , Y finalmente (before.next = node, node.next = temp), que es equivalente a señalar antes al nodo, nodo apuntando al nodo actual (temp).
* @param index
* @param object
* /
public void addElement (int index, Object object) {
SingleNode node = new SingleNode (object, null);
if (index> 0 && index <size) {
SingleNode temp = first;
SingleNode before = null;
for (int i = 0; i <index; i ++) {
before = temp;
temp = temp.next;
}
before.next = nodo;
node.next = temp;
tamaño ++;
}
}
/ **
* 展示 链表 中 的 节点 元素
* /
public void show () {
if (! IsEmpty ()) {
SingleNode current = first;
while (current! = null) {
System.out.println (current.object);
actual = actual.siguiente;
}
}
}
/ **
* Obtener los elementos del nodo especificado
* Análisis de ideas: defina un puntero, realice un bucle a la posición especificada y saque el elemento
* @param index
* @return
* /
public Object get (int index) {
if (index> 0 && index <size) {
if (!
IsEmpty ()) { SingleNode temp = first;
for (int i = 0; i <index; i ++) {
temp = temp.next;
}
return temp.object;
}
}
return null;
}
/ **
* eliminar el elemento del nodo especificado
* Análisis de ideas: es necesario definir dos punteros para registrar Elimine el nodo y el nodo anterior del nodo que se va a eliminar, luego coloque before.next = temp.next
* @param index
* /
public void remove (int index) {
if (index> 0 && index <size) {
if (! isEmpty ()) {
SingleNode temp = first;
SingleNode beforeTemp = null;
for (int i = 0; i <index; i ++) {
beforeTemp = temp;
temp = temp.next;
}
beforeTemp.next = temp.next;
}
}
}
/ **
* 修改 指定 节点 的 指定 元素
*
* @param index
* @param object
* /
public void update (int index, Object object) {
if (index> 0 && index <size) {
if (! IsEmpty ()) {
SingleNode temp = first ;
for (int i = 0; i <index; i ++) {
temp = temp.next;
}
temp.object = object;
}
}
}
/ **
* Impresión inversa de listas vinculadas
* Análisis de ideas: uso de la pila avanzada Características, primero coloque el elemento en la pila y luego sáquelo.
* /
public void rePrint () {
Stack <SingleNode> stack = new Stack <SingleNode> ();
if (! isEmpty ()) {
SingleNode current = first;
while (current! = null) {
stack.push (current);
current = current.next;
}
while (stack.size ()> 0) {
System.out.println (stack.pop (). object);
}
}
}
/ **
* 将 单 链表 反转
* /
public void reversetList () {
SingleNode current = first;
SingleNode before = null;
while (current! = null) {
last = before;
antes = actual;
actual = actual.siguiente;
before.next = last;
}
actual = antes;
while (current! = null) {
System.out.println (current.object);
actual = actual.siguiente;
}
}