Implementación de Estructuras de Datos: Lista Simple Enlazada con Punteros de Cabecera y Cola

Enviado por Programa Chuletas y clasificado en Informática y Telecomunicaciones

Escrito el en español con un tamaño de 13,34 KB

Implementación de Lista Simple Enlazada con Punteros de Inicio y Fin

Definición de Tipos (TIPO)

pnodo: *Nodo

Nodo: Registro
    Dato: Tipo_Dato
    Sig: pnodo
FinRegistro

T_Lista: Registro
    i, f: pnodo  // i: inicio, f: final
FinRegistro

Declaración de Variables (VAR)

L: T_Lista

Operaciones Fundamentales de la Lista Enlazada

Función Crear_Nodo(n: Tipo_Dato): pnodo

Var
    p: pnodo
Inicio
    p := NEW(p)
    Si p <> NULL entonces
        p*dato := n
        p*sig := NULL
    FinSi
    Crear_Nodo := p
Fin

Procedimiento Inicializar_Lista(var L: T_Lista)

Inicio
    L.i := NULL
    L.f := NULL
Fin

Procedimiento Agregar_Inicio(var L: T_Lista, nuevo: pnodo)

Inicio
    Si L.i = NULL y L.f = NULL entonces
        L.i := nuevo
        L.f := nuevo
    Sino
        nuevo*sig := L.i
        L.i := nuevo
    FinSi
Fin

Procedimiento Agregar_Final(var L: T_Lista, nuevo: pnodo)

Var
    P: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        L.i := nuevo
        L.f := nuevo
    Sino
        L.f*sig := nuevo
        L.f := nuevo
    FinSi
Fin

Función Sacar_Inicio(var L: T_Lista): pnodo

Var
    Sacado: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Sacado := NULL
    Sino
        Sacado := L.i
        Si L.i*sig = NULL entonces
            L.i := NULL
            L.f := NULL
        Sino
            L.i := Sacado*sig
            Sacado*sig := NULL
        FinSi
    FinSi
    Sacar_Inicio := Sacado
Fin

Función Sacar_Final(var L: T_Lista): pnodo

Var
    Sacado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Sacado := NULL
    Sino
        Si L.i*sig = NULL entonces
            Sacado := L.i
            L.i := NULL
            L.f := NULL
        Sino
            p := L.i
            Mientras (p*sig)*sig <> NULL hacer
                p := p*sig
            FinMientras
            Sacado := p*sig
            p*sig := NULL
            L.f := p
        FinSi
    FinSi
    Sacar_Final := Sacado
Fin

Procedimiento Ordenar_Lista(var L: T_Lista, nuevo: pnodo)

Nota: Este procedimiento inserta el nuevo nodo manteniendo la lista ordenada.

Var
    p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        L.i := nuevo
        L.f := nuevo
    Sino
        // Caso 1: Insertar al inicio
        Si L.i*dato >= nuevo*dato entonces
            nuevo*sig := L.i
            L.i := nuevo
        Sino
            // Caso 2: Insertar al final (si es mayor que el último)
            Si L.f*dato <= nuevo*dato entonces
                L.f*sig := nuevo
                L.f := nuevo
            Sino
                // Caso 3: Insertar en medio
                p := L.i
                Mientras (p*sig <> NULL) y ((p*sig)*dato < nuevo*dato) hacer
                    p := p*sig
                FinMientras
                nuevo*sig := p*sig
                p*sig := nuevo
            FinSi
        FinSi
    FinSi
Fin

Función Buscar_Valor(L: T_Lista, dato_buscado: Tipo_Dato): pnodo

Var
    Buscado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Buscado := NULL
    Sino
        p := L.i
        Mientras (p <> NULL y p*dato <> dato_buscado) hace
            p := p*sig
        FinMientras
        Buscado := p
    FinSi
    Buscar_Valor := Buscado
Fin

Procedimiento Mostrar_Lista(L: T_Lista)

Var
    p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Escribir "La lista está vacía"
    Sino
        p := L.i
        Mientras p <> NULL hacer
            Escribir p*dato
            p := p*sig
        FinMientras
    FinSi
Fin

Función Sacar_Buscado(L: T_Lista, dato_buscado: Tipo_Dato): pnodo

Var
    sacado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        sacado := NULL
    Sino
        // Caso 1: Solo hay un elemento
        Si L.i*sig = NULL entonces
            Si L.i*dato = dato_buscado entonces
                Sacado := L.i
                L.i := NULL
                L.f := NULL
            FinSi
        Sino
            // Caso 2: El elemento buscado es el primero
            Si L.i*dato = dato_buscado entonces
                Sacado := L.i
                L.i := Sacado*sig
                Sacado*sig := NULL
            Sino
                // Caso 3: El elemento buscado está en medio o al final
                p := L.i
                Mientras ((p*sig <> NULL) y ((p*sig)*dato <> dato_buscado)) hace
                    p := p*sig
                FinMientras

                Si (p*sig = NULL) entonces
                    // No se encontró el valor
                    Sacado := NULL
                Sino
                    // Se encontró el valor (p*sig es el nodo a sacar)
                    Si ((p*sig)*sig = NULL) entonces
                        // Es el último nodo
                        Sacado := p*sig
                        p*sig := NULL
                        L.f := p
                    Sino
                        // Es un nodo intermedio
                        sacado := p*sig
                        p*sig := sacado*sig
                        sacado*sig := NULL
                    FinSi
                FinSi
            FinSi
        FinSi
    FinSi
    Sacar_Buscado := sacado
Fin

Bloque de Código Redundante (Material Original)

El siguiente bloque de código fue encontrado al final del documento original y parece ser una repetición parcial de las funciones de extracción y ordenamiento. Se mantiene intacto según las instrucciones.

Función Sacar_Inicio (Redundante)

Sacado := NULL
Sino
    Sacado := L.i
    Si L.i*sig = NULL entonces
        L.i := NULL
        L.f := NULL
    Sino
        L.i := Sacado*sig
        Sacado*sig := NULL
    FinSi
FinSi
Sacar_Inicio := Sacado
Fin

Función Sacar_Final(var L: T_Lista): pnodo (Redundante)

Var
    Sacado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Sacado := NULL
    Sino
        Si L.i*sig = NULL entonces
            Sacado := L.i
            L.i := NULL
            L.f := NULL
        Sino
            p := L.i
            Mientras (p*sig)*sig <> NULL hacer
                p := p*sig
            FinMientras
            Sacado := p*sig
            p*sig := NULL
            L.f := p
        FinSi
    FinSi
    Sacar_Final := Sacado
Fin

Procedimiento Ordenar_Lista(var L: T_Lista, nuevo: pnodo) (Redundante)

Var
    p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        L.i := nuevo
        L.f := nuevo
    Sino
        Si L.i*dato >= nuevo*dato entonces
            nuevo*sig := L.i
            L.i := nuevo
        Sino
            Si L.f*dato <= nuevo*dato entonces
                L.f*sig := nuevo
                L.f := nuevo
            Sino
                p := L.i
                Mientras (p*sig <> NULL) y ((p*sig)*dato < nuevo*dato) hacer
                    p := p*sig
                FinMientras
                nuevo*sig := p*sig
                p*sig := nuevo
            FinSi
        FinSi
    FinSi
Fin

Función Buscar_Valor(L: T_Lista, dato_buscado: Tipo_Dato): pnodo (Redundante)

Var
    Buscado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Buscado := NULL
    Sino
        p := L.i
        Mientras (p <> NULL y p*dato <> dato_buscado) hace
            p := p*sig
        FinMientras
        Buscado := p
    FinSi
    Buscar_Valor := Buscado
Fin

Procedimiento Mostrar_Lista(L: T_Lista) (Redundante)

Var
    p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        Escribir "La lista está vacía"
    Sino
        p := L.i
        Mientras p <> NULL hacer
            Escribir p*dato
            p := p*sig
        FinMientras
    FinSi
Fin

Función Sacar_Buscado(L: T_Lista, dato_buscado: Tipo_Dato): pnodo (Redundante)

Var
    sacado, p: pnodo
Inicio
    Si L.i = NULL y L.f = NULL entonces
        sacado := NULL
    Sino
        Si L.i*sig = NULL entonces
            Si L.i*dato = dato_buscado entonces
                Sacado := L.i
                L.i := NULL
                L.f := NULL
            FinSi
        Sino
            Si L.i*dato = dato_buscado entonces
                Sacado := L.i
                L.i := Sacado*sig
                Sacado*sig := NULL
            Sino
                p := L.i
                Mientras ((p*sig <> NULL) y ((p*sig)*dato <> dato_buscado)) hace
                    p := p*sig
                FinMientras
                Si (p*sig = NULL) entonces
                    Sacado := NULL
                Sino
                    Si ((p*sig)*sig = NULL) entonces
                        Sacado := p*sig
                        p*sig := NULL
                        L.f := p
                    Sino
                        sacado := p*sig
                        p*sig := sacado*sig
                        sacado*sig := NULL
                    FinSi
                FinSi
            FinSi
        FinSi
    FinSi
    Sacar_Buscado := sacado
Fin
Karma: 8%
Visitas: 0

Entradas relacionadas:

Etiquetas:
nodo lista enlazada simple cola Puntero al inicio telecomunicaciones ordenamiento punteros búsqueda programación creación de nodo algoritmos operaciones de lista informática pseudocódigo estructura de datos cabecera