O(1) - MADS Group

Grado en Ingeniería Informática
SSeminario:
i i
Estructuras de Datos
© Óscar Fontenla Romero y Elena Hernández Pereira
{oscar.fontenla, elena.hernandez}@udc.es
Estructuras de Datos: Colas
• Ejercicio 1: A partir de la siguiente estructura de datos para la implementación de listas enlazadas:
tipo PNodo = puntero a Nodo
Nodo = registro
Elem : TipoElemento
Sig : PNodo
fin registro
C l = PNodo
Cola
PN d
Estructuras de Datos: Colas
A. Escribir el pseudocódigo de las siguientes operaciones:
CrearCola(p) que crea una cola vacía.
EsColaVacia(p) que comprueba si la cola está vacía.
Insertar(x,p) que inserta x en la cola.
Primero(p) que devuelve el elemento de la cabeza de la cola.
EliminarPrimero(p) que elimina la cabeza de la cola.
Si se utiliza algún procedimiento auxiliar, reflejar también su pseudocódigo.
B. Indicar, razonando la respuesta sobre el pseudocódigo, la complejidad computacional de cada una de las operaciones anteriores.
Estructuras de Datos: Colas
• Solución:
procedimiento CrearCola (var p)
p := nil
fin procedimiento
p
funcion EsColaVacia (p) : test
devolver p = nil
fin funcion
Estructuras de Datos: Colas
• Solución:
procedimiento CrearCola (var p)
p := nil
{O(1)}
fin procedimiento
p
funcion EsColaVacia (p) : test
devolver p = nil
fin funcion
Estructuras de Datos: Colas
• Solución:
procedimiento CrearCola (var p)
p := nil
{O(1)}
fin p
procedimiento {
{O(1)}
( )}
funcion EsColaVacia (p) : test
devolver p = nil
fin funcion
Estructuras de Datos: Colas
• Solución:
procedimiento CrearCola (var p)
p := nil
{O(1)}
fin p
procedimiento {
{O(1)}
( )}
funcion EsColaVacia (p) : test
devolver p = nil {
{O(1)}
( )}
fin funcion
Estructuras de Datos: Colas
• Solución:
procedimiento CrearCola (var p)
p := nil
{O(1)}
fin p
procedimiento {
{O(1)}
( )}
funcion EsColaVacia (p) : test
devolver p = nil {
{O(1)}
( )}
fin funcion {O(1)}
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r);
si r = nil entonces
error Memoria agotada
sino
r^.Elem := x;
r^.Sig := nil;
fin procedimiento
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ;
si
i EsColaVacia
i (p) entonces
p := tmp;
sino
q := p;
mientras q^.Sig <> nil hacer
q := q^.Sig;
q^.Sig
q
Sig := tmp;
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
si r = nil entonces
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ;
si
i EsColaVacia
i (p) entonces
p := tmp;
sino
q := p;
mientras q^.Sig <> nil hacer
q := q^.Sig;
q^.Sig
q
Sig := tmp;
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ;
si
i EsColaVacia
i (p) entonces
p := tmp;
sino
q := p;
mientras q^.Sig <> nil hacer
q := q^.Sig;
q^.Sig
q
Sig := tmp;
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ;
si
i EsColaVacia
i (p) entonces
p := tmp;
sino
q := p;
mientras q^.Sig <> nil hacer
q := q^.Sig;
q^.Sig
q
Sig := tmp;
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ; {O(1)}
si
i EsColaVacia
i (p) entonces
p := tmp;
sino
q := p;
mientras q^.Sig <> nil hacer
q := q^.Sig;
q^.Sig
q
Sig := tmp;
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ; {O(1)}
si
i EsColaVacia
i (p) entonces
p := tmp; {O(1)}
sino
q := p; {O(1)}
mientras q^.Sig <> nil hacer
q := q^.Sig;
{O(1)}
q^.Sig
q
Sig := tmp; {O(1)}
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ; {O(1)}
si
i EsColaVacia
i (p) entonces {O(1)}
{ (1)}
p := tmp; {O(1)}
sino
q := p; {O(1)}
mientras q^.Sig <> nil hacer
q := q^.Sig;
{O(1)}
q^.Sig
q
Sig := tmp; {O(1)}
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ; {O(1)}
si
i EsColaVacia
i (p) entonces {O(1)}
{ (1)}
p := tmp; {O(1)}
sino
q := p; {O(1)}
mientras q^.Sig <> nil hacer {O(n)}
q := q^.Sig;
{O(1)}
q^.Sig
q
Sig := tmp; {O(1)}
fin procedimiento
Estructuras de Datos: Colas
• Solución:
procedimiento CrearNodo (x , var r)
nuevo (r); {O(1)}
{ ( )}
si r = nil entonces {O(1)}
error Memoria agotada {O(1)}
sino
r^.Elem := x; {O(1)}
r^.Sig := nil; {O(1)}
fin procedimiento {O(1)}
procedimiento Insertar (x , var p)
CrearNodo (x , tmp) ; {O(1)}
si
i EsColaVacia
i (p) entonces {O(1)}
{ (1)}
p := tmp; {O(1)}
sino
q := p; {O(1)}
mientras q^.Sig <> nil hacer {O(n)}
q := q^.Sig;
{O(1)}
q^.Sig
q
Sig := tmp; {O(1)}
fin procedimiento {O(n)}
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces
error Cola vacía
sino
devolver p^.Elem
fin funcion
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces
error Cola vacía;
sino
tmp := p;
p := p^.Sig;
liberar (tmp);
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces
error Cola vacía;
sino
tmp := p;
p := p^.Sig;
liberar (tmp);
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces {O(1)}
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces
error Cola vacía;
sino
tmp := p;
p := p^.Sig;
liberar (tmp);
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces {O(1)}
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion {O(1)}
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces
error Cola vacía;
sino
tmp := p;
p := p^.Sig;
liberar (tmp);
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces {O(1)}
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion {O(1)}
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces
error Cola vacía; {O(1)}
sino
tmp := p; {O(1)}
{ (1)}
p := p^.Sig; {O(1)}
liberar (tmp); {O(1)}
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces {O(1)}
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion {O(1)}
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces {O(1)}
error Cola vacía; {O(1)}
sino
tmp := p; {O(1)}
{ (1)}
p := p^.Sig; {O(1)}
liberar (tmp); {O(1)}
fi procedimiento
fin
di i t
Estructuras de Datos: Colas
• Solución:
funcion Primero (p) : TipoElemento
si EsColaVacia (p) entonces {O(1)}
error Cola vacía {O(1)}
{ ( )}
sino
devolver p^.Elem {O(1)}
fin funcion {O(1)}
procedimiento EliminarPrimero (var p)
si EsColaVacia (p) entonces {O(1)}
error Cola vacía; {O(1)}
sino
tmp := p; {O(1)}
{ (1)}
p := p^.Sig; {O(1)}
liberar (tmp); {O(1)}
fi procedimiento
fin
di i t {O(1)}
Estructuras de Datos: ABB
• Ejercicio 2: A partir de la siguiente estructura de datos para la implementación de un árbol binario de búsqueda:
tipo PArbol = puntero a Nodo
Nodo = registro
Elem : TipoElemento
Izq, Der : PArbol
fin registro
ABB = PArbol
PA b l
Estructuras de Datos: ABB
A. Diseñar, escribiendo el pseudocódigo, un recorrido del árbol en orden de nivel (es decir, todos los nodos de profundidad p se procesan antes que cualquier nodo con profundidad p+1). Reflejar en el diseño todos los procedimientos y estructuras de datos necesarias.
B. Determinar, razonando la respuesta sobre el pseudocódigo, la complejidad computacional de cada una de las operaciones anteriores.
C. Indicar y justificar que modificaciones habría que realizar sobre las estructuras de datos utilizadas y/o sobre la rutina de recorrido diseñada, para que esta se ejecutase en tiempo lineal.
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil
fin funcion
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol
arbol^.Elem
.Elem
fin funcion
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces
error Arbol vacío
sino
devolver arbol^.Der
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol
arbol^.Elem
.Elem
fin funcion
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces
error Arbol vacío
sino
devolver arbol^.Der
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces
error Arbol vacío
sino
devolver arbol^.Der
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces
error Arbol vacío
sino
devolver arbol^.Der
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion {O(1)}
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces
error Arbol vacío
sino
devolver arbol^.Der
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion {O(1)}
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces {
{O(1)}
( )}
error Arbol vacío {O(1)}
sino
devolver arbol^.Der {O(1)}
fin funcion
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion {O(1)}
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces {
{O(1)}
( )}
error Arbol vacío {O(1)}
sino
devolver arbol^.Der {O(1)}
fin funcion {O(1)}
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces
error Arbol vacío
sino
devolver arbol^.Izq
fin funcion
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
funcion
f
i
E A b lV i (arbol)
EsArbolVacio
( b l) : test
t t
devolver arbol = nil {O(1)}
fin funcion {O(1)}
funcion Raiz (arbol) : TipoElemento
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol
arbol^.Elem
.Elem {O(1)}
fin funcion {O(1)}
funcion HijoDerecho (arbol) : PArbol
si EsArbolVacio (
(arbol)
) entonces {
{O(1)}
( )}
error Arbol vacío {O(1)}
sino
devolver arbol^.Der {O(1)}
fin funcion {O(1)}
funcion HijoIzquierdo (arbol) : PArbol
si EsArbolVacio (arbol) entonces {O(1)}
error Arbol vacío {O(1)}
sino
devolver arbol^.Izq {O(1)}
fin funcion {O(1)}
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces
CrearCola (p);
Insertar (arbol , p);
repetir
arbolTemp := Primero (p);
EliminarPrimero (p);
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p);
Insertar (arbol , p);
repetir
arbolTemp := Primero (p);
EliminarPrimero (p);
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p);
repetir
arbolTemp := Primero (p);
EliminarPrimero (p);
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p);
EliminarPrimero (p);
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p);
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp))
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp);
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p);
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp);
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp); {O(1)}
si no EsArbolVacio(der)
E A b lV i (d ) entonces
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp); {O(1)}
si no EsArbolVacio(der)
E A b lV i (d ) entonces {O(1)}
Insertar (der , p);
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp); {O(1)}
si no EsArbolVacio(der)
E A b lV i (d ) entonces {O(1)}
Insertar (der , p); {O(n)}
hasta EsColaVacia (p);
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp); {O(1)}
si no EsArbolVacio(der)
E A b lV i (d ) entonces {O(1)}
Insertar (der , p); {O(n)}
hasta EsColaVacia (p); {O(n)}
fin procedimiento
Estructuras de Datos: ABB
• Solución (empleando una cola con lista enlazada simple):
procedimiento Recorrido (arbol)
si no EsArbolVacio (arbol) entonces {O(1)}
CrearCola (p); {O(1)}
Insertar (arbol , p); {O(n)}
repetir
arbolTemp := Primero (p); {O(1)}
EliminarPrimero (p); {O(1)}
Visualiza (Raiz (arbolTemp)) {O(1)}
izq := HijoIzquierdo (arbolTemp); {O(1)}
si
i no EsArbolVacio(izq)
b l
i (i ) entonces
t
{O(1)}
Insertar (izq , p); {O(n)}
der := HijoDerecho (arbolTemp); {O(1)}
si no EsArbolVacio(der)
E A b lV i (d ) entonces {O(1)}
Insertar (der , p); {O(n)}
hasta EsColaVacia (p); {O(n)}
fin procedimiento {O(n2)}
Estructuras de Datos: ABB
C. Indicar y justificar que modificaciones habría que realizar sobre las estructuras de datos utilizadas y/o sobre la rutina de recorrido diseñada, para que esta se ejecutase en tiempo lineal.
Estructuras de Datos: ABB
C. Indicar y justificar que modificaciones habría que realizar sobre las estructuras de datos utilizadas y/o sobre la rutina de recorrido diseñada, para que esta se ejecutase en tiempo lineal.
Utilizar una cola circular como estructura para volcar los p
datos del árbol. De esta forma la operación de Insertar es de orden O(1) en lugar de O(n).