Listas en el Área de Informática

Una lista es una estructura de datos que organiza elementos de manera secuencial, donde
cada elemento tiene una posición específica. Cada elemento en la lista se conoce como un nodo, y
cada nodo contiene datos y una referencia al siguiente nodo en la secuencia. Las listas son
fundamentales en programación y se utilizan para almacenar y manipular colecciones de datos de
manera eficiente.

Características:
• Secuencialidad: Los elementos en una lista están dispuestos en un orden secuencial.
Cada elemento tiene una posición específica y se puede acceder a ellos siguiendo esa
secuencia.

• Dinamismo: Las listas pueden cambiar en tamaño durante la ejecución del programa.
Puedes agregar o eliminar elementos fácilmente, lo que proporciona flexibilidad en la
gestión de datos.

• Acceso directo (en listas basadas en arreglos): En las listas basadas en arreglos,
el acceso a un elemento específico es rápido y directo utilizando su índice. Esto hace que
las operaciones de lectura sean eficientes.

• Inserción y eliminación eficientes (en listas enlazadas): Las listas enlazadas

permiten insertar o eliminar elementos en cualquier posición de la lista de manera
eficiente, ya que solo se requiere ajustar las referencias de los nodos afectados.

• Flexibilidad en el tipo de datos: Las listas pueden contener elementos de diferentes

tipos de datos. Esto significa que puedes almacenar tanto números como cadenas de
texto, objetos complejos u otros tipos de datos en una lista.
• Implementación de estructuras de datos más complejas: Las listas se utilizan
como base para implementar otras estructuras de datos como pilas, colas, filas de
prioridad y listas doblemente enlazadas, entre otras.

• Uso de iteradores: Muchas implementaciones de listas permiten el uso de iteradores,

lo que facilita la iteración sobre los elementos de la lista de manera ordenada.

• Almacenamiento dinámico de memoria: Las listas permiten un manejo más flexible

de la memoria, ya que pueden crecer o reducirse según sea necesario durante la ejecución
del programa

Tipos:
• Listas enlazadas: En este tipo de lista, cada nodo contiene datos y un puntero
(referencia) al siguiente nodo en la secuencia. La última referencia suele ser nula para
indicar el final de la lista. Las listas enlazadas pueden ser simples, doblemente enlazadas
(donde cada nodo tiene referencias al anterior y al siguiente), o circulares (donde el último
nodo apunta al primero).

• Listas basadas en arreglos o arrays: Estas listas utilizan un bloque contiguo de

memoria para almacenar elementos. Cada elemento ocupa una posición en el arreglo, y se
puede acceder directamente a través de su índice. Aunque las operaciones de acceso son
eficientes, la inserción y eliminación de elementos pueden ser más costosas en
comparación con las listas enlazadas.

Características:
• Almacenamiento de datos secuenciales: Las listas se utilizan para
almacenar datos que tienen un orden específico y deben ser procesados en esa
secuencia.
 • Implementación de estructuras de datos: Las listas sirven como la base
para implementar otras estructuras de datos más complejas, como pilas, colas,
filas de prioridad y listas doblemente enlazadas.

• Manejo de conjuntos de elementos: Las listas son ideales para representar

conjuntos de elementos relacionados, como una lista de tareas, una lista de
contactos, una lista de productos en un carrito de compras, etc.

• Iteración sobre elementos: Las listas facilitan la iteración sobre sus

elementos, lo que es útil al realizar operaciones repetitivas o al procesar datos en
lotes.

• Implementación de colas y filas: Al usar listas, puedes implementar colas

(FIFO) y filas (LIFO) para gestionar elementos en función de su orden de llegada o
salida.

• Algoritmos de búsqueda y ordenación: Las listas son utilizadas en

algoritmos de búsqueda y ordenación, ya que permiten organizar y acceder a los
datos de manera eficiente.

• Manejo de historial o registros: Las listas son útiles para almacenar un

historial de eventos o registros, como el historial de navegación en un navegador
web.

• Implementación de grafos: En estructuras de datos como grafos, las listas a

menudo se utilizan para representar las relaciones entre nodos.

• Manejo de datos en aplicaciones de bases de datos: En entornos de

bases de datos, las listas pueden representar conjuntos de resultados de consultas
o registros seleccionados.

• Almacenamiento de información en memoria dinámica: Las listas

permiten el manejo dinámico de la memoria al permitir la inserción y eliminación
de elementos de manera eficiente, lo que es útil en situaciones donde el tamaño
de los datos no se conoce de antemano.

Lista Simple:
Estructura de datos lineal que organiza elementos de manera secuencial, donde cada
elemento (nodo) contiene un dato y una referencia al siguiente nodo en la secuencia. El último
nodo de la lista suele tener una referencia nula, indicando el final de la lista.
class Nodo:
def __init__(self, dato):
self.dato = dato
self.siguiente = None

nodo1 = Nodo(10)
nodo2 = Nodo(20)
nodo3 = Nodo(30)

nodo1.siguiente = nodo2
nodo2.siguiente = nodo3

current = nodo1
while current is not None:
print(current.dato, end=" -> ")
current = current.siguiente
print("None")

Lista Encuadernada/Enlazada:
Estructura de datos lineal que consta de nodos, donde cada nodo contiene datos y un
enlace (referencia) al siguiente nodo en la secuencia. El último nodo suele tener una referencia
nula, indicando el final de la lista. Puede ser una lista enlazada simple, doblemente enlazada o
circular.

class Nodo:
def __init__(self, dato):
self.dato = dato
self.siguiente = None

class ListaEnlazada:
def __init__(self):
self.cabeza = None

def agregar_elemento_al_final(self, dato):

nuevo_nodo = Nodo(dato)
 if self.cabeza is None:
self.cabeza = nuevo_nodo
else:
temp = self.cabeza
while temp.siguiente is not None:
temp = temp.siguiente
temp.siguiente = nuevo_nodo

def imprimir_lista(self):
temp = self.cabeza
while temp is not None:
print(temp.dato, end=" -> ")
temp = temp.siguiente
print("None")

mi_lista_enlazada = ListaEnlazada()
mi_lista_enlazada.agregar_elemento_al_final(10)
mi_lista_enlazada.agregar_elemento_al_final(20)
mi_lista_enlazada.agregar_elemento_al_final(30)

mi_lista_enlazada.imprimir_lista()

Listas Circulares:
estructura de datos enlazada en la que el último nodo de la lista apunta al primer nodo, creando
un bucle cerrado. Cada nodo contiene un dato y un enlace al siguiente nodo en la secuencia. Las
listas circulares pueden ser simples o doblemente enlazadas.

class Nodo:
def __init__(self, dato):
self.dato = dato
self.siguiente = None

class ListaCircular:
def __init__(self):
self.cabeza = None

def agregar_elemento(self, dato):

nuevo_nodo = Nodo(dato)
if self.cabeza is None:
 self.cabeza = nuevo_nodo
nuevo_nodo.siguiente = self.cabeza
else:
temp = self.cabeza
while temp.siguiente != self.cabeza:
temp = temp.siguiente
temp.siguiente = nuevo_nodo
nuevo_nodo.siguiente = self.cabeza

def imprimir_lista(self):
if self.cabeza is not None:
temp = self.cabeza
while True:
print(temp.dato, end=" -> ")
temp = temp.siguiente
if temp == self.cabeza:
break
print(" (Inicio de la lista)")

mi_lista_circular = ListaCircular()
mi_lista_circular.agregar_elemento(10)
mi_lista_circular.agregar_elemento(20)
mi_lista_circular.agregar_elemento(30)

mi_lista_circular.imprimir_lista()

Operaciones con Listas:

• Creación:

# Python
mi_lista = [1, 2, 3, 4, 5]

• Inserción:

# Python
mi_lista.append(6)
mi_lista.insert(2, 7)
 • Supresión:

# Python
mi_lista.remove(3)
del mi_lista[2]

Algoritmo de Listas:

inventario = []

def agregar_producto(nombre, cantidad):

producto = {'nombre': nombre, 'cantidad': cantidad}
inventario.append(producto)
print(f"{nombre} agregado al inventario con {cantidad} unidades.")

def actualizar_existencias(nombre, cantidad):

for producto in inventario:
if producto['nombre'] == nombre:
producto['cantidad'] += cantidad
print(f"Existencias de {nombre} actualizadas a {producto['cantidad']} unidades.")
return
print(f"No se encontró el producto {nombre} en el inventario.")

def mostrar_inventario():
print("Inventario:")
for producto in inventario:
print(f"{producto['nombre']}: {producto['cantidad']} unidades")

agregar_producto("Camiseta", 50)
agregar_producto("Pantalón", 30)
actualizar_existencias("Camiseta", 20)
mostrar_inventario()