El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Ejercicios con Listas

Siguiente ►
►

En esta sección, pondremos en práctica los conceptos aprendidos sobre listas, listas enlazadas, listas doblemente enlazadas y listas circulares. A través de estos ejercicios, reforzarás tu comprensión y habilidades en la manipulación de estas estructuras de datos.

Ejercicio 1: Implementación de una Lista Enlazada

Enunciado

Implementa una lista enlazada simple en Python. La lista debe soportar las siguientes operaciones:

  • Insertar un elemento al final.
  • Eliminar un elemento dado.
  • Buscar un elemento.

Solución

Paso 1: Definir la clase Nodo

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

Paso 2: Definir la clase ListaEnlazada

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

    def insertar_al_final(self, dato):
        nuevo_nodo = Nodo(dato)
        if not self.cabeza:
            self.cabeza = nuevo_nodo
            return
        ultimo = self.cabeza
        while ultimo.siguiente:
            ultimo = ultimo.siguiente
        ultimo.siguiente = nuevo_nodo

    def eliminar(self, dato):
        temp = self.cabeza
        if temp is not None:
            if temp.dato == dato:
                self.cabeza = temp.siguiente
                temp = None
                return
        while temp is not None:
            if temp.dato == dato:
                break
            prev = temp
            temp = temp.siguiente
        if temp == None:
            return
        prev.siguiente = temp.siguiente
        temp = None

    def buscar(self, dato):
        temp = self.cabeza
        while temp:
            if temp.dato == dato:
                return True
            temp = temp.siguiente
        return False

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

Paso 3: Probar la implementación

lista = ListaEnlazada()
lista.insertar_al_final(1)
lista.insertar_al_final(2)
lista.insertar_al_final(3)
lista.imprimir_lista()  # Output: 1 -> 2 -> 3 -> None

lista.eliminar(2)
lista.imprimir_lista()  # Output: 1 -> 3 -> None

print(lista.buscar(3))  # Output: True
print(lista.buscar(2))  # Output: False

Ejercicio 2: Implementación de una Lista Doblemente Enlazada

Enunciado

Implementa una lista doblemente enlazada en Python. La lista debe soportar las siguientes operaciones:

  • Insertar un elemento al final.
  • Eliminar un elemento dado.
  • Buscar un elemento.

Solución

Paso 1: Definir la clase NodoDoble

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

Paso 2: Definir la clase ListaDoblementeEnlazada

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

    def insertar_al_final(self, dato):
        nuevo_nodo = NodoDoble(dato)
        if not self.cabeza:
            self.cabeza = nuevo_nodo
            return
        ultimo = self.cabeza
        while ultimo.siguiente:
            ultimo = ultimo.siguiente
        ultimo.siguiente = nuevo_nodo
        nuevo_nodo.anterior = ultimo

    def eliminar(self, dato):
        temp = self.cabeza
        if temp is not None:
            if temp.dato == dato:
                self.cabeza = temp.siguiente
                if self.cabeza:
                    self.cabeza.anterior = None
                temp = None
                return
        while temp is not None:
            if temp.dato == dato:
                break
            temp = temp.siguiente
        if temp == None:
            return
        if temp.siguiente:
            temp.siguiente.anterior = temp.anterior
        if temp.anterior:
            temp.anterior.siguiente = temp.siguiente
        temp = None

    def buscar(self, dato):
        temp = self.cabeza
        while temp:
            if temp.dato == dato:
                return True
            temp = temp.siguiente
        return False

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

Paso 3: Probar la implementación

lista_doble = ListaDoblementeEnlazada()
lista_doble.insertar_al_final(1)
lista_doble.insertar_al_final(2)
lista_doble.insertar_al_final(3)
lista_doble.imprimir_lista()  # Output: 1 <-> 2 <-> 3 <-> None

lista_doble.eliminar(2)
lista_doble.imprimir_lista()  # Output: 1 <-> 3 <-> None

print(lista_doble.buscar(3))  # Output: True
print(lista_doble.buscar(2))  # Output: False

Ejercicio 3: Implementación de una Lista Circular

Enunciado

Implementa una lista circular en Python. La lista debe soportar las siguientes operaciones:

  • Insertar un elemento al final.
  • Eliminar un elemento dado.
  • Buscar un elemento.

Solución

Paso 1: Definir la clase Nodo

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

Paso 2: Definir la clase ListaCircular

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

    def insertar_al_final(self, dato):
        nuevo_nodo = Nodo(dato)
        if not self.cabeza:
            self.cabeza = nuevo_nodo
            nuevo_nodo.siguiente = self.cabeza
            return
        temp = self.cabeza
        while temp.siguiente != self.cabeza:
            temp = temp.siguiente
        temp.siguiente = nuevo_nodo
        nuevo_nodo.siguiente = self.cabeza

    def eliminar(self, dato):
        if self.cabeza is None:
            return
        temp = self.cabeza
        prev = None
        while True:
            if temp.dato == dato:
                if prev:
                    prev.siguiente = temp.siguiente
                else:
                    if temp.siguiente == self.cabeza:
                        self.cabeza = None
                    else:
                        self.cabeza = temp.siguiente
                        ultimo = self.cabeza
                        while ultimo.siguiente != temp:
                            ultimo = ultimo.siguiente
                        ultimo.siguiente = self.cabeza
                return
            prev = temp
            temp = temp.siguiente
            if temp == self.cabeza:
                break

    def buscar(self, dato):
        temp = self.cabeza
        while True:
            if temp.dato == dato:
                return True
            temp = temp.siguiente
            if temp == self.cabeza:
                break
        return False

    def imprimir_lista(self):
        if not self.cabeza:
            print("Lista vacía")
            return
        temp = self.cabeza
        while True:
            print(temp.dato, end=" -> ")
            temp = temp.siguiente
            if temp == self.cabeza:
                break
        print()

Paso 3: Probar la implementación

lista_circular = ListaCircular()
lista_circular.insertar_al_final(1)
lista_circular.insertar_al_final(2)
lista_circular.insertar_al_final(3)
lista_circular.imprimir_lista()  # Output: 1 -> 2 -> 3 ->

lista_circular.eliminar(2)
lista_circular.imprimir_lista()  # Output: 1 -> 3 ->

print(lista_circular.buscar(3))  # Output: True
print(lista_circular.buscar(2))  # Output: False

Conclusión

En esta sección, hemos implementado y probado diferentes tipos de listas: listas enlazadas, listas doblemente enlazadas y listas circulares. Cada tipo de lista tiene sus propias características y ventajas, y es importante comprender cuándo y cómo utilizarlas en la programación. Los ejercicios proporcionados te ayudarán a reforzar tu comprensión y habilidades en la manipulación de estas estructuras de datos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados