11 KiB
title | localeTitle |
---|---|
Data Structure Linked List | Lista enlazada de estructura de datos |
Al igual que una guirnalda está hecha con flores, una lista enlazada está formada por nodos. Llamamos a cada flor en esta guirnalda particular para ser un nodo. Y cada uno de los nodos apunta al siguiente nodo en esta lista, así como también tiene datos (aquí es el tipo de flor).
Los tipos
- Lista enlazada individualmente
Las listas enlazadas individualmente contienen nodos que tienen un campo de data
así como un campo next
, que apunta al siguiente nodo en la secuencia. Las operaciones que se pueden realizar en listas enlazadas individualmente son inserción, eliminación y recorrido.
`
Singly Link List
head
|
|
+-----+--+ +-----+--+ +-----+------+
| 1 |o-----> | 2 |o-----> | 3 | NULL |
+-----+--+ +-----+--+ +-----+------+
`
Solicitud
Implementación interna de CPython, los marcos y las variables evaluadas se mantienen en una pila.
Para esto necesitamos iterar solo hacia adelante aur get the head, por lo tanto se usa una lista enlazada individualmente.
- Lista doblemente vinculada
Las listas doblemente enlazadas contienen un nodo que tiene data
campo de data
, el next
campo y otro campo de enlace prev
apuntando al nodo anterior en la secuencia.
`
Lista doblemente vinculada
head
|
|
+------+-----+--+ +--+-----+--+ +-----+------+
| | |o------> | |o------> | | |
| NULL | 1 | | 2 | | 3 | NULL |
| | | <------o| | <------o| | |
+------+-----+--+ +--+-----+--+ +-----+------+
`
Solicitud
El caché del navegador que le permite presionar el botón ATRÁS y ADELANTE. Aquí necesitamos mantener una lista doblemente enlazada, con las URLs
como campo de datos, para permitir el acceso en ambas direcciones. Para ir a la URL anterior usaremos el campo prev
y para ir a la página next
usaremos el next
campo.
- Lista enlazada circular
Las listas enlazadas circulares son una lista enlazada individualmente en la que el último nodo, el next
campo apunta al primer nodo en la secuencia.
`
Lista enlazada circular
head
|
|
+-----+--+ +-----+--+ +-----+--+
-> | 1 | o -----> | 2 | o -----> | 3 | o ----
| + ----- + - + + ----- + - + + ----- + - + |
| |
`
Solicitud
Problema de multipropiedad resuelto por el sistema operativo.
En un entorno de tiempo compartido, el sistema operativo debe mantener una lista de los usuarios actuales y, alternativamente, debe permitir que cada usuario use una pequeña parte del tiempo de CPU, un usuario a la vez. El sistema operativo seleccionará un usuario, le permitirá usar una pequeña cantidad de tiempo de CPU y luego pasar al siguiente usuario.
Para esta aplicación, no debería haber punteros NULL a menos que no haya absolutamente nadie solicitando el tiempo de CPU, es decir, la lista está vacía.
Operaciones básicas
- Inserción
Para agregar un nuevo elemento a la lista.
`
Inserción al principio
- Crea un nuevo nodo con los datos dados.
- Apunta el nuevo nodo al
next
de lahead
vieja. - Punto de
head
a este nuevo nodo.
Inserción en el medio / final
Inserción después del nodo X.
- Crea un nuevo nodo con los datos dados.
- Nuevo punto de nodo
next
al antiguo X delnext
. - El punto X está
next
a este nuevo nodo.
`
Complejidad del tiempo: O (1)
- Supresión
Para eliminar elementos existentes de la lista.
`
Supresión al inicio
- Obtener el nodo señalado por la
head
como Temp. - Punto de
head
a lanext
la temperatura. - Memoria libre utilizada por el nodo Temp.
Eliminación en el medio / final
Eliminación después del nodo X.
- Obtener el nodo señalado por
X
como Temp. - Del punto X
next
a de temperaturanext
. - Memoria libre utilizada por el nodo Temp.
`
Complejidad del tiempo: O (1)
- Atravesando
Para viajar por la lista.
`
Travesía
- Obtener el nodo señalado por la
head
como actual. - Compruebe si la corriente no es nula y visualícela.
- El punto actual a la corriente es el
next
y pasar al paso anterior.
`
Complejidad de tiempo: O (n) // Aquí n es el tamaño de la lista de enlaces
Implementación
Implementación en C ++ de una lista unida
// Header files
#include <iostream>
struct node
{
int data;
struct node *next;
};
// Head pointer always points to first element of the linked list
struct node *head = NULL;
Impresión de datos en cada nodo.
// Display the list
void printList()
{
struct node *ptr = head;
// Start from the beginning
while(ptr != NULL)
{
std::cout << ptr->data << " ";
ptr = ptr->next;
}
std::cout << std::endl;
}
Inserción al principio
// Insert link at the beginning
void insertFirst(int data)
{
// Create a new node
struct node *new_node = new struct node;
new_node->data = data;
// Point it to old head
new_node->next = head;
// Point head to new node
head = new_node;
std::cout << "Inserted successfully" << std::endl;
}
Supresión al inicio
// Delete first item
void deleteFirst()
{
// Save reference to head
struct node *temp = head;
// Point head to head's next
head = head->next;
// Free memory used by temp
temp = NULL:
delete temp;
std::cout << "Deleted successfully" << std::endl;
}
tamaño
// Find no. of nodes in link list
void size()
{
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next)
{
length++;
}
std::cout << "Size of Linked List is " << length << std::endl;
}
buscando
// Find node with given data
void find(int data){
// Start from the head
struct node* current = head;
// If list is empty
if(head == NULL)
{
std::cout << "List is empty" << std::endl;
return;
}
// Traverse through list
while(current->data != data){
// If it is last node
if(current->next == NULL){
std::cout << "Not Found" << std::endl;
return;
}
else{
// Go to next node
current = current->next;
}
}
// If data found
std::cout << "Found" << std::endl;
}
Eliminación después de un nodo
// Delete a node with given data
void del(int data){
// Start from the first node
struct node* current = head;
struct node* previous = NULL;
// If list is empty
if(head == NULL){
std::cout << "List is empty" << std::endl;
return ;
}
// Navigate through list
while(current->data != data){
// If it is last node
if(current->next == NULL){
std::cout << "Element not found" << std::endl;
return ;
}
else {
// Store reference to current node
previous = current;
// Move to next node
current = current->next;
}
}
// Found a match, update the node
if(current == head) {
// Change head to point to next node
head = head->next;
}
else {
// Skip the current node
previous->next = current->next;
}
// Free space used by deleted node
current = NULL;
delete current;
std::cout << "Deleted succesfully" << std::endl;
}
Implementación de Python de la lista enlazada individualmente
class Node(object):
# Constructor
def __init__(self, data=None, next=None):
self.data = data
self.next = next
# Function to get data
def get_data(self):
return self.data
# Function to get next node
def get_next(self):
return self.next
# Function to set next field
def set_next(self, new_next):
self.next = new_next
class LinkedList(object):
def __init__(self, head=None):
self.head = head
Inserción
# Function to insert data
def insert(self, data):
# new_node is a object of class Node
new_node = Node(data)
new_node.set_next(self.head)
self.head = new_node
print("Node with data " + str(data) + " is created succesfully")
tamaño
# Function to get size
def size(self):
current = self.head
count = 0
while current:
count += 1
current = current.get_next()
print("Size of link list is " + str(count))
buscando
# Function to search a data
def search(self, data):
current = self.head
found = False
while current and found is False:
if current.get_data() == data:
found = True
else:
current = current.get_next()
if current is None:
print("Node with data " + str(data) + " is not present")
else:
print("Node with data " + str(data) + " is found")
Eliminación después de un nodo
# Function to delete a node with data
def delete(self, data):
current = self.head
previous = None
found = False
while current and found is False:
if current.get_data() == data:
found = True
else:
previous = current
current = current.get_next()
if current is None:
print("Node with data " + str(data) + " is not in list")
elif previous is None:
self.head = current.get_next()
print("Node with data " + str(data) + " is deleted successfully")
else:
previous.set_next(current.get_next())
print("Node with data " + str(data) + " is deleted successfully")
Ventajas
- Las listas enlazadas son una estructura de datos dinámica, que puede aumentar y disminuir, asignando y desasignando memoria mientras el programa se está ejecutando.
- La inserción y eliminación de nodos se implementan fácilmente en una lista vinculada en cualquier posición.
Desventajas
- Utilizan más memoria que las matrices debido a la memoria utilizada por sus punteros (
next
yprev
). - El acceso aleatorio no es posible en la lista enlazada. Tenemos que acceder a los nodos de forma secuencial.
- Es más complejo que la matriz. Si un idioma admite la comprobación de la matriz de forma automática, Arrays le será de mayor utilidad.
Nota
Tenemos que usar free () en C y eliminar en C ++ para liberar el espacio utilizado por el nodo eliminado, mientras que, en Python y Java, el espacio libre es recolectado automáticamente por el recolector de basura.