En la programación Java, las estructuras de datos juegan un papel vital. Estas estructuras de datos pueden ayudarnos a organizar y administrar datos, haciendo que nuestro código sea más eficiente y fácil de mantener. Una de ellas es que LinkedListes una estructura de datos flexible que nos permite realizar operaciones de inserción y eliminación de manera eficiente. Este blog profundizará en Java LinkedList, desde conceptos básicos hasta uso avanzado, y le presentará información completa.
1. ¿Qué es LinkedList?
LinkedListEs una estructura de datos de lista doblemente enlazada en Java. Consiste en una secuencia de nodos, cada uno de los cuales contiene elementos de datos y referencias a los nodos anterior y siguiente. Esta estructura hace que LinkedListlas operaciones de inserción y eliminación sean muy eficientes porque no requiere reasignación de espacio de memoria como las matrices.
2. Crear e inicializar LinkedList
En Java, puedes crear e inicializar usando LinkedList:
LinkedList<String> linkedList = new LinkedList<>();
Esto crea un objeto vacío LinkedListpara almacenar los elementos de cadena. También puedes inicializar usando una colección existente LinkedList, por ejemplo:
List<String> stringList = new ArrayList<>();
stringList.add("苹果");
stringList.add("香蕉");
LinkedList<String> linkedList = new LinkedList<>(stringList);
Esto creará un elemento que contiene "manzana" y "plátano" LinkedList.
3. Operaciones básicas
3.1 Agregar elementos
3.1.1 addMétodo
Para LinkedListagregar elementos a un , puedes usar addel método. Agrega elementos al final de la lista.
linkedList.add("橙子");
3.1.2 Agregar elemento en la posición especificada
También puede utilizar addel método para insertar un elemento en una posición específica. La posición especificada está determinada por el índice, comenzando desde 0.
linkedList.add(1, "葡萄"); // 在索引 1 处插入 "葡萄"
3.2 Obtener elementos
3.2.1 getMétodo
Para obtener LinkedListun elemento, puede utilizar getel método, especificando el índice del elemento.
String fruit = linkedList.get(0); // 获取第一个元素
3.3 Eliminar elementos
3.3.1 removeMétodo
Para eliminar LinkedListelementos de , puede utilizar removeel método. Puede especificar el elemento que se eliminará o el índice del elemento que se eliminará.
linkedList.remove("香蕉"); // 删除 "香蕉"
linkedList.remove(1); // 删除索引 1 处的元素
4. Atravesar la lista enlazada
El recorrido LinkedListse puede realizar de diferentes formas, las más comunes son mediante for-eachbucles o iteradores.
4.1 Usando for-eachbucles
for (String fruit : linkedList) {
System.out.println(fruit);
}
4.2 Usando iteradores
Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
5. Operaciones especiales
5.1 Agregar elementos al principio y al final
LinkedListPermite la adición eficiente de elementos al principio y al final.
5.1.1 Agregar elementos al principio
linkedList.addFirst("草莓");
5.1.2 Agregar elementos al final
linkedList.addLast("樱桃");
5.2 Insertar elementos en posiciones específicas
LinkedListTambién permite insertar elementos en posiciones específicas.
linkedList.add(2, "葡萄"); // 在索引 2 处插入 "葡萄"
5.3 Reemplazar elementos
Puede utilizar setel método para reemplazar LinkedListelementos en .
linkedList.set(1, "蓝莓"); // 将索引 1 处的元素替换为 "蓝莓"
6. Consideraciones de desempeño
6.1 Comparación con ArrayList
Existe una compensación de rendimiento al considerar el uso de LinkedList. En comparación con ArrayList, LinkedListgeneralmente es más rápido en las operaciones de inserción y eliminación porque no requiere mover una gran cantidad de elementos. Sin embargo, tiene un rendimiento deficiente al acceder a elementos de forma aleatoria porque la lista vinculada debe recorrerse comenzando desde el principio o el final.
6.2 Complejidad del tiempo
- Agregar y eliminar elementos: la complejidad del tiempo promedio es O (1) (cuando se conoce la posición), en el peor de los casos O (n) (si es necesario atravesar toda la lista vinculada).
- Obtener elementos: la complejidad del tiempo promedio es O (n/2) (en el caso promedio, es necesario atravesar la mitad de la lista vinculada).
- Acceso aleatorio a elementos: O (n) en el peor de los casos (debe recorrer toda la lista vinculada desde el principio o el final).
7. Precauciones de uso
Al utilizar LinkedList, debe prestar atención a los siguientes asuntos:
LinkedListNo es seguro para subprocesos. Si se utiliza en varios subprocesos, se deben tomar medidas de sincronización adecuadas o considerar alternativas seguras para subprocesos.- Evite el acceso aleatorio excesivo ya que tiene un rendimiento deficiente. Considere su uso si se requiere acceso aleatorio frecuente
ArrayList. - Úselo grande con precaución
LinkedListya que puede consumir mucha memoria.
8. Uso avanzado
8.1 Lista doblemente enlazada
LinkedListes una implementación de una lista doblemente enlazada, lo que significa que cada nodo contiene una referencia al nodo anterior y al siguiente. Esta conexión bidireccional hace que recorrer la lista enlazada hacia adelante y hacia atrás sea muy eficiente. A continuación se muestran algunos ejemplos de uso avanzado de listas doblemente enlazadas:
8.1.1 Recorrer la lista vinculada en orden inverso
LinkedListLa naturaleza bidireccional de facilita el recorrido en orden inverso. Puede comenzar a recorrer desde el final de la lista vinculada y seguir la referencia del nodo anterior hasta llegar al encabezado de la lista vinculada.
LinkedList<String> linkedList = new LinkedList<>();
// 添加元素到链表
// ...
// 逆序遍历链表
ListIterator<String> iterator = linkedList.listIterator(linkedList.size());
while (iterator.hasPrevious()) {
String item = iterator.previous();
System.out.println(item);
}
8.1.2 Insertar elementos en posiciones específicas
La propiedad de una lista doblemente enlazada hace que la inserción de un elemento en una ubicación específica sea más eficiente porque puede atravesarla en ambas direcciones. Esto puede proporcionar beneficios de rendimiento cuando es necesario insertar un elemento en medio de una lista vinculada.
LinkedList<String> linkedList = new LinkedList<>();
// 添加元素到链表
// ...
// 在中间位置插入元素
ListIterator<String> iterator = linkedList.listIterator(linkedList.size() / 2); // 在中间位置开始
iterator.add("新元素");
8.2 Lista circular enlazada
LinkedListTambién se puede utilizar como una lista enlazada circular, es decir, el último nodo de la lista enlazada apunta al primer nodo, formando un bucle cerrado. Esta estructura es muy útil en ciertos algoritmos y estructuras de datos, como las colas circulares.
LinkedList<String> circularList = new LinkedList<>();
circularList.add("元素1");
circularList.add("元素2");
circularList.add("元素3");
// 构建循环链表，将最后一个元素指向第一个元素
circularList.getLast().setNext(circularList.getFirst());
// 遍历循环链表
Node<String> currentNode = circularList.getFirst();
do {
System.out.println(currentNode.getData());
currentNode = currentNode.getNext();
} while (currentNode != circularList.getFirst());
8.3 Listas enlazadas como colas y pilas
LinkedListSe puede utilizar como implementaciones de cola y pila. Admite operaciones de primero en entrar, primero en salir (FIFO) para colas y operaciones de último en entrar, primero en salir (LIFO) para pilas. A continuación se muestra LinkedListun ejemplo de cómo implementar colas y pilas usando:
8.3.1 Implementar cola usando lista vinculada
LinkedList<String> queue = new LinkedList<>();
// 入队
queue.offer("元素1");
queue.offer("元素2");
// 出队
String item = queue.poll();
8.3.2 Implementar pila usando lista vinculada
LinkedList<String> stack = new LinkedList<>();
// 入栈
stack.push("元素1");
stack.push("元素2");
// 出栈
String item = stack.pop();
Estos usos avanzados demuestran LinkedListflexibilidad y funcionalidad en una variedad de escenarios. Dependiendo de sus necesidades, puede aprovechar al máximo sus funciones de lista doblemente enlazada para resolver el problema.
9. Código de muestra
Aquí hay un LinkedListcódigo de muestra usando:
// 创建一个 LinkedList
LinkedList<String> linkedList = new LinkedList<>();
// 添加元素
linkedList.add("苹果");
linkedList.add("香蕉");
// 获取元素
String fruit = linkedList.get(0);
// 删除元素
linkedList.remove("香蕉");
// 遍历 LinkedList
for (String item : linkedList) {
System.out.println(item);
}
10. Resumen
LinkedListEs una poderosa estructura de datos en Java que es muy eficiente en operaciones de inserción y eliminación. Sin embargo, el rendimiento es deficiente al acceder a elementos de forma aleatoria, así que utilícelos con cuidado. Espero que este blog pueda ayudarle a comprenderlo y utilizarlo mejor LinkedListy a tomar decisiones acertadas al escribir código Java. Ya sea que sea un principiante o un desarrollador experimentado, dominarlo LinkedListagregará nuevas herramientas y técnicas a su viaje de programación.