Estructura de Datos Avanzada PDF

Estructuras de Datos
Avanzadas
Contenido del Tema
TT
6.1. Introducción
EE 6.2. Pilas
M
M 6.3. Colas
6.4. Listas
AA 6.5. Arboles Binarios.
Arboles Binarios de Búsqueda
66 6.6. Otras Estructuras.
Metodología de Programación
Introducción
Objetivos
• Especificación e Implementación de nuevas
estructuras de datos Técnica: Abstracción de
Datos
• Tipos de Estructuras de Datos:
1) Datos organizados por Posición Pilas , Colas
y Listas
2) Datos organizados por Valor Arboles Binarios
1
Introducción
• Estudio de las Estructuras de Datos:
Definición de la Estructura de Datos e
identificación de su Conjunto de
Operaciones
Desarrollo de diversas Implementaciones
Presentación de Aplicaciones
Pilas
Definición
• Pila: Grupo Ordenado, (de Añadir Eliminar
acuerdo al tiempo que llevan
en la pila) de Elementos
Homogéneos (todos del
mismo tipo).
• Acceso a la Pila: añadir y

eliminar elementos, SÓLO a

través de la CABEZA de la
Pila
• Estructura LIFO (L Last Input

First Output)
2
Pilas. Operaciones
Conjunto de Operaciones
MÓDULO MPila
DEFINICIÓN
TIPOS
TElemento= // cualquier tipo de datos
TPila= // por definir
PROC MeterPila(↓↑pila:TPila; ↓elem: TElemento)
// Añade un elemento por la cabeza de la pila
PROC SacarPila(↓↑pila:TPila;↑elem:TElemento)
// Saca un elemento por la cabeza de la Pila
Pilas. Operaciones
FUNC CrearPila():TPila
// Crea una pila vacía
FUNC PilaVacia (↓pila :TPila):LÓGICO
// Nos dice si una pila está vacía
FUNC PilaLlena(↓pila:TPila):LÓGICO
// Nos dice si una pila está llena.
PROC DestruirPila(↓↑ pila:TPila)
// Destruye una pila previamente creada
Fin
3
Pilas. Implementación
Implementación
1) Con un Array
• Array estructura adecuada Elementos Homogéneos
• Elementos almacenados de forma Secuencial
CONSTANTES
MAXPILA ← 100
TIPOS
TElemento = ENTERO
TPila = ARRAY[1..MAXPILA]DE TElemento
Sólo es posible acceder a la Cabeza de la Pila
¿ Cómo es posible conocer la posición de la cabeza?
1) Variable entera “cabeza” Inconveniente: se ha de pasar

como parámetro adicional a todas las operaciones sobre la
pila
2) Extender el array, en pila[0] almacenaremos el índice del
elemento que ocupa la cabeza actual
4
CONSTANTES
CABEZA ← 0
MAXPILA ← 100
TIPOS
TPila = ARRAY[CABEZA..MAXPILA]DE TElemento
3 5 3 2
.......

2
[0] [1] [2] [3] [99] [100] 3
5

Pilas.Implementación
• Inconveniente: Solo es posible implementar una pila de

enteros (no de cualquier otro tipo de datos)
• Solución: CONSTANTES
MAXPILA ← 100
TIPOS
TPila=REGISTRO
Cabeza:NATURAL
Elementos: ARRAY[1..MAXPILA] DE

TElemento

!
!
"
"
#
#
k 5 13 8 .........
1 2 k MAXPILA
5
IMPLEMENTACIÓN FUNC PilaLlena(↓pila:TPila
FUNC CrearPila():TPila ):LÓGICO
VARIABLES INICIO
pila:TPila
RESULTADO ←(pila.Cabeza
INICIO = MAXPILA)
pila.Cabeza ← 0 FIN
RESULTADO ← pila
FIN
PROC
FUNC PilaVacia(↓pila:TPila
DestruirPila(↓↑pila:TPila)
):LÓGICO
INICIO
INICIO
// No hay que hacer nada.
RESULTADO←pila.Cabeza=0 FIN
FIN
PROC SacarPila(↓↑pila:TPila; PROC MeterPila(↓↑pila:TPila;
↑elem:TElemento) ↓elem :TElemento)
INICIO INICIO
elem ← pila.Elementos pila.Cabeza←pila.Cabeza+1
[pila.Cabeza] pila.Elementos
pila.Cabeza←pila.Cabeza-1 [pila.Cabeza] ← elem
FIN FIN
/* precondición: /* precondición:
la pila no ha de estar llena
la pila no ha de estar vacía
*/
*/
6
PROC MeterPila (↓↑pila:TPila; PROC SacarPila(↓↑pila:TPila ;
↓elem:TElemento; ↑elem:TElemento;
↑llena : LÓGICO) ↑vacia:LÓGICO)
Inicio INICIO
llena ←PilaLlena(pila) vacia ← PilaVacia(pila)
SI (¬llena) ENTONCES SI ¬vacia ENTONCES
pila.Cabeza ← elem ← pila.Elementos
pila.Cabeza + 1 [pila.Cabeza]
pila.Elementos
pila.Cabeza ←pila.Cabeza-1
[pila.Cabeza] ← elem
FINSI
FINSI
FIN
Fin
/* Sin precondición. Saca un
/* Sin Prec ondición.Introduce elemento de la pila si no
un elemento en la pila si está vacía*/
no está llena */
2) Con una Lista Enlazada de Punteros
• Comienzo de una lista enlazada Cabeza de la Pila
TIPOS
TPila = PUNTERO A TNodoPila
TNodoPila = REGISTRO
dato:TElemento
sig: TPila
FINREGISTRO
' ( ) * + (
' ( ) * + (
, -
, -
&
$ % &
$ %
.
.
7
PROC MeterPila(↓↑pila:TPila; PROC SacarPila(↓↑pila:TPila;
↑elem: TElemento; ↑elem :TElemento;
↑llena: LÓGICO) ↑vacía: LÓGICO)
VARIABLES VARIABLES
nuevonodo : TPila ptr: TPila
INICIO
INICIO
vacía ← PilaVacía(pila)
llena ← FALSO SI ¬vacía ENTONCES
nuevonodo ← elem ← pila^.dato
NUEVO(TNodoPila) ptr ← pila
nuevonodo^.dato ← elem pila ← pila^.sig
ELIMINAR(ptr)
nuevonodo^.sig ← pila
FINSI
pila ← nuevonodo FIN
FIN
PROC CrearPila():TPila PROC DestruirPila(↓↑pila:TPila)
INICIO Variables
RESULTADO ← NULO ptr: TPila
Fin Inicio
MIENTRAS(pila≠ NULO)HACER
FUNC PilaVacia(pila :TPila ptr ← pila
):LÓGICO
pila ← pila^.sig
INICIO
ELIMINAR(ptr)
RESULTADO ← (pila= NULO) FINMIENTRAS
FIN FIN
8
Pilas. Aplicaciones
Aplicaciones
• Ejemplo1:
Ejemplo1: Leer una secuencia de caracteres desde teclado
e imprimirla al revés
• Ejemplo2:
Ejemplo2: Verificar si una cadena de caracteres está
balanceada en paréntesis o no
abc(
abc(defg(
defg(ijk))(l(
ijk))(l(mn
mn))op)
op)qr SI
abc(
abc(def))
def))ghij
ghij((kl)m
kl)m NO
• Ejemplo3:
Ejemplo3: Reconocimiento del Lenguaje,
L={W$W´ / W es una cadena de caracteres y W´es su
inversa} (Suponemos que $ no está ni en W ni en W´)
Pilas. Ejemplo1
ALGORITMO Inverso MIENTRAS (c≠ENTER) ∧
DESDE MPila IMPORTA (¬ll) HACER
TPila, CrearPila, MeterPila(pila,c,ll)
MeterPila, SacarPila, Leer(c)
Pilavacia, DestruirPila FINMIENTRAS
CONSTANTES SacarPila(pila,c,v)
ENTER ← CHR(13) MIENTRAS
TIPOS (¬PilaVacia(pila))HACER
TElemento = CARÁCTER SacarPila(pila,c,v)
VARIABLES Escribir(c)
c : TElemento FINMIENTRAS
pila : TPila DestruirPila(pila)
ll,v:LÓGICO FIN
INICIO
pila ← CrearPila()
LEER(c)
9
Pilas. Ejemplo2
ALGORITMO Balanceo MIENTRAS(bien ∧ (c≠ENTER)HACER
DESDE MPila IMPORTA CrearPila, TPila, SI c= ‘(’ ENTONCES
MeterPila, SacarPila, PilaVacia, MeterPila(pila,c,ll)
DestruirPila
bien ← ¬ll
CONSTANTES
EN OTRO CASO
ENTER ← CHR(13)
Tipos SI c = ‘)’ ENTONCES
TElemento = CARÁCTER SacarPila(pila,c,v)
VARIABLES bien ← ¬v
c : TElemento FINSI
pila : TPila FINSI
bien,ll, v : LÓGICO LEER(c)
Inicio FINMIENTRAS
pila ← CrearPila() SI bien ∧ PilaVacia(pila) ENTONCES
bien ← CIERTO Escribir(“cadena balanceada “)
LEER(c) EN OTRO CASO
Escribir(“cadena no balanceada”)
FINSI
DestruirPila(pila)
FIN
Pilas. Ejemplo3
Algoritmo Lenguaje_L Leer(c1)
DESDE MPila IMPORTA TPila, bien ← TRUE
CrearPila, MeterPila, MIENTRAS (bien ∧ (c1 ≠ENTER))
SacarPila, DestruirPila HACER
CONSTANTES SacarPila(pila,c2,v)
ENTER ← CHR(13) bien ← (¬v) ∧ (c1=c2)
TIPOS /* He podido sacar el
TElemento = CARÁCTER elemnto y conicide
VARIABLES */
c1, c2 : TElemento SI (bien) ENTONCES
pila : TPila Leer(c1)
bien, ll, v : LÓGICO FINSI
Inicio FINMIENTRAS
pila ← CrearPila() SI (bien ∧
ll ← FALSO PilaVacia(pila))ENTONCES
LEER(c1) Escribir(“ Si pertenece”)
MIENTRAS (c1 ≠‘$’)∧(¬ll) HACER EN OTRO CASO
MeterPila(pila,c1,ll) Escribir (“No pertenece”)
LEER(c1) FINSI
FINMIENTRAS DestruirPila(pila)
FIN
10
Pilas. Aplicaciones
• Aplicaciones complejas que se pueden solucionar con
pilas: Expresiones Algebraicas
Operadores: +, -, *, /
Operandos: Letras mayúsculas
• Notación Infija:
Infija:
• El operador binario está situado entre sus dos operandos
A+ B
• Inconveniente: Son necesarias reglas de precedencia y uso
de paréntesis para evitar ambigüedades A+B*C
Pilas. Aplicaciones
Notación Prefija Notación Postfija
• El operador binario esta situado • El operador binario está situado
justo antes de sus dos justo después de sus dos
operandos +AB operandos AB+
• Gramática: • Gramática:
<expr_pref>::=<letra>|<operador> <exp_post>::=<letra>|<expr_post>
<expr_pref><expr_pref> <exp_post><operador>
<letra> ::= A| B ....|Z <letra> ::=A| B ....|Z
<operador> ::= + | - | * | / <operador> ::= + | - | * | /
• Ejemplos: • Ejemplos:
A+(B*C) +A*BC A+(B*C) ABC*+
(A+B)*C *+ABC (A+B)*C AB+C*
11
Pilas. Aplicaciones
• Ventaja: Usando expresiones prefijas y postfijas no son
necesarias reglas de precedencia, ni uso de paréntesis.
Las gramáticas que las generan son muy simples, y los
algoritmos que las reconocen y evaluan muy fáciles
• Ejemplo 4: Algoritmo que evalúa una expresión en notación
Postfija
1)Usaremos una pila
2)La expresión postfija se almacenará en un array de caracteres
y será correcta
3)Los operadores serán: +, -, * y /
4)Los operandos serán letras mayúsculas (a cada una le
podemos asignar un valor)
Pilas. Ejemplo4
CONSTANTES INICIO
MAX ← 20 CASO c SEA
‘A’ : res ← 5
TIPOS ‘B’ : res ← 7
TArray = ARRAY[1..MAX] DE ‘C’ : res ← -1
CARÁCTER ‘D’ : res ← 11
TElemento=ENTERO EN OTRO CASO
res ← 0
FUNC Operando(↓c:CARACTER) FINCASO
:ENTERO RESULTADO ← res
VARIABLES FIN
res:ENTERO
12
Pilas. Ejemplo4
FUNC Eval_postfija(↓exp: TArray; ↓ultimo:NATURAL):ENTERO
DESDE MPila IMPORTA TPila, CrearPila, MeterPila, SacarPila,

DestruirPila
Variables
pila : TPila
i, op1, op2, result : ENTERO
c : CARÁCTER
v,ll:LÓGICO
FUNC es_operador(↓c:CARÁCTER):LÓGICO
INICIO
RESULTADO ← (c=`*´) ∨ (c=`/´) ∨ (c=`+´) ∨ (c=`-´}
FIN
Pilas. Ejemplo4
Inicio
pila ← CrearPila()
PARA i ← 1 HASTA ultimo HACER
c ← exp[i]
SI es_operador(c) ENTONCES
SacarPila(pila,op2,v)
SacarPila(pila,op1,v)
CASO c SEA
‘+’ :MeterPila(pila,op1+op2,ll)
‘-’ : MeterPila(pila,op1-op2,ll)
‘*’ : MeterPila(pila,op1*op2,ll)
‘/’ : MeterPila(pila, op1/op2,ll)
FINCASO
EN OTRO CASO
MeterPila(pila, Operando(c))
FINSI
FINPARA
SacarPila(pila,result)
DestruirPila(pila)
RESULTADO ← result
Fin
13
Colas
Definición
• Cola: es un grupo ordenado (con respecto al tiempo que
llevan en él) de elementos homogéneos (todos del mismo
Tipo)
• Acceso: los elementos se añaden por un extremo (final) y
se sacan por el otro extremo (frente)
• Estructura FIFO (First Input First Output)
= > ? > @
= > ? > @
9 : ; : <
4 5 6 7 8 9 : ; : <
/ 0 1 2 3 1 4 5 6 7 8
/ 0 1 2 3 1
Colas. Operaciones
MODULO MCola
DEFINICIÓN
TIPOS
TElemento =// cualquier tipo de datos
TCola= // por definir
FUNC CrearCola(): TCola // Crea una cola vacia
FUNC ColaVacia(↓cola:TCola): LÓGICO
/* Operación lógica que nos dice si la cola
contiene algún elemento o no*/
14
Colas. Operaciones
FUNC ColaLlena(↓cola:TCola):LÓGICO
/* Operación lógica que nos dice si la cola está
llena o no */
PROC MeterCola(↓↑cola: TCola; ↓elem: TElemento)
// Introduce un elemento al final de la cola/
PROC SacarCola(↓↑cola: TCola; ↑elem: TElemento)
// Saca un elemento del frente de la cola
PROC DestruirCola(↓↑cola:TCola)
// Destruye una cola previamente creada
Fin
Colas. Implementación
Implementación
1) Con un Array
• Se deja fijo el frente de la cola y se mueve el final a medida que se
añaden nuevos elementos (Idem Pila)
• Las operaciones Meter, Crear, ColaVacia y ColaLlena se implementan
de una forma similar a sus análogas en Pilas
• La operación de Sacar es mas complicada: cada vez que saquemos un
elemento de la cola se han de desplazar el resto una posición en el
array, para hacer coincidir el frente con la primera posición del array
• Ventaja Simplicidad
• Inconveniente Ineficiente (colas con muchos elementos o
elementos grandes)
15
• Ejemplo:
A B C D E E E E E E E E E E
F G H I J K L
F G H I J K L
Meter(Cola,”A”) Q
Q
L M N O P P P P P P P P P P
L M N O P P P P P P P P P P
Meter(cola, “B”) Q
Q
W
W X
X
Y
Y
Z
Z
[
[
\
\
]
]
^
^
R S T U V V V V V V V V V V
R S T U V V V V V V V V V V
W
W
Sacar(cola, elem)
elem)
Desplazar
W
W
_
_
X Y Z [ \ ]
X Y Z [ \ ]
_
_
^ ` a b b b b b b b b b b
^ ` a b b b b b b b b b b
Solución:
• Utilizar un indice para el frente y otro para el final y

permitir que ambos fluctuen por el array
• Ventaja: operación Sacar más sencilla

• Inconveniente: Es posible que final sea igual a Maxcola
(última casilla del array) y que la cola no esté llena
16
• Ejemplo:
j k l m n l o p
j k l m n l o p
Meter(Cola,”A”) h
h
j
j
q
q
m
m
r
r
s
s
o
o
p
p
c d e f g g g g g g g g g g
j k l m n l o p
j k l m n l o p
Meter(cola, “B”) h
h
i
i
j q m r s o t
j q m r s o t
Meter(cola, “C”) x
x
y
y
z
z
{
{
|
|
}
}
~
~

}
}

{ ~
{ ~
p t u v w w w w w w w w w w
p t u v w w w w w w w w w w
Sacar(cola,elem
Sacar(cola,elem))

z
z
{
{
|
|
}
}
~
~

}
}

{ ~
{ ~

• Solución:
• Tratar al array como una Estructura Circular,
Circular donde la
última posición va seguida de la primera Evitamos que
el final de la cola alcance el final físico del array y no esté
llena
• Operación Meter Añade elementos a las posiciones del
array e incrementa el índice final
• Operación Sacar Más sencilla. Sólo se incrementa el
índice frente a la siguiente posición
17
• Ejemplo:

£ ¤ ¥ ¦ § ¥ ¨ ©
¢ £ ¤ ¥ ¦ § ¥ ¨ ©
¢
£ ¤ ¥ ¦ § ¥ ¨ ©
£ ¤ ¥ ¦ § ¥ ¨ ©

£ ª ¦ « ¬ ¨
£ ª ¦ « ¬ ¨
£
£
ª
ª
¦
¦
«
«
¬
¬
¨
¨
®
®

Meter(cola,”G”)

Sacar(cola,elem
Sacar(cola,elem))

¡
¡
¡
¡

¿Como sabemos si la cola está vacía o llena?

¯
¯
Á
À Á
À
µ ¶ · ¸ ¹ · º »
´ µ ¶ · ¸ ¹ · º »
´
É
É
µ ¶ · ¸ ¹ · º »
µ ¶ · ¸ ¹ · º »
Æ
´ Æ
´
®
®
¿
¿ ³ °
³ °
Meter(cola,”L”)
È µ ¼ ¸ ½ ¾ º ¿
È µ ¼ ¸ ½ ¾ º ¿
Ã Å
Ã Å
µ ¼ ¸ ½ ¾ º
µ ¼ ¸ ½ ¾ º
Á
Á
²
²
Ë Ë Ì Í Î Ï Î Î Ð Ñ Ï Ë Ë
Ê Ë Ë Ì Í Î Ï Î Î Ð Ñ Ï Ë Ë
Ê
Ä
Ä
Ç
Ç
©
©
»
» ±
±
Â
Â
Ó
Ò Ó
Ò
Ó
Ò Ó
Ò
Õ
Õ
Ô
Ô
Ù Ú Û Ü Ý Û Þ
× Ô Ù Ú Û Ü Ý Û Þ
× Ô
Ù
Ù
Ú
Ú
Û
Û
Ü
Ü
Ý
Ý
Û
Û
Ô
Ô
Þ
Þ
×
×
Ø
Ø Ô
Ô
Sacar(cola,elem
Sacar(cola,elem)) Ô
Ô
Ù ß Ü à á Þ
Ù ß Ü à á Þ
Ù ß Ü à á Þ
Ù ß Ü à á Þ
Ö Õ
Ö Õ
â â ã ä å æ ç æ è é æ â â
â â ã ä å æ ç æ è é æ â â
Ö Õ
Ö Õ
18
• Solución:
• 1) Disponer de otra variable Contabilizará los
elementos almacenados en la cola
Variable=0 Cola vacía
Variable=MaxCola Cola llena
Inconveniente: añade más procesamiento a las operaciones
Meter y Sacar
• 2) Frente apunte a la casilla del array que precede a la del
elemento frente de la cola Solución elegida
• Ejemplo: ê
ê
ë
ë
ê
ê
ë
ë
û
û
ò ó ô õ ö ô ÷ í
ï ñ ì
ï ñ ì
ò
ò
ø
ø
õ
õ
ù
ù
ú
ú
÷
÷
ï
ï
ï
ï
ñ
ñ
ì
ì
Meter(cola,”G”) ò
ò
ø
ø
õ
õ
ù
ù
ú
ú
÷
÷
ê
ê
ð
ð
ð
ð
î í
î í
î í
î í
¿Como saber si la cola está llena? Es necesario que la posición a la

que apunta frente en cada momento este Reservada
Cola Llena: final+
final+1 =frente
ë
ê ë
ê
ý
ü ý
ü
ò ó ô õ ö ô ÷ ì
ò ó ô õ ö ô ÷ ì
ï ñ ì
ï ñ ì
ÿ
ÿ
ë
ò ø õ ù ú ÷ ë
ò ø õ ù ú ÷
ð
ð
þ
þ
î í
î í
19
¿Como saber si la cola está vacía?
Cola Vacía: Frente = Final

Sacar(cola,elem
Sacar(cola,elem))

• Crear la cola (inicializarla vacía): frente =Maxcola (índice

del array que precede al elemento frente de la cola) y
final=Maxcola Cola Vacía correcto (frente = final)
• Agrupamos en un registro los índices frente y final, junto
con el array que contendrá los elementos de la cola
CONSTANTES
MAXCOLA ← 100
TIPOS
TElemento = // Cualquier tipo de datos
TCola = REGISTRO
elementos:ARRAY[1..MAXCOLA]DE TElemento
Frente,Final : [1.. MAXCOLA]
FINREGISTRO

Maxcola
5 13 ...................

1 2 MaxCola

20
FUNC CrearCola():TCola FUNC ColaLlena(↓cola:Tcola
VARIABLES ):LÓGICO
cola: TCola INICIO
INICIO RESULTADO ←
cola.Frente ← MAXCOLA (cola.Final MOD MAXCOLA)+1
cola.Final ← MAXCOLA = cola.Frente
RESULTADO ← cola FIN
FIN FUNC ColaVacia(↓cola:Tcola
PROC DestruirCola(↓↑cola ):LÓGICO
:TCola) INICIO
INICIO ← cola.Final =
RESULTADO←
// No hay que hacer nada. cola.Frente
FIN FIN
PROC MeterCola(↓↑cola:TCola; PROC SacarCola(↓↑cola:TCola;
↓elem:TElemento) ↑elem:TElemento)
VARIABLES VARIABLES
fin:NATURAL ini:NATURAL
INICIO INICIO
fin ← (cola.Final MOD ini ← (cola.Frente MOD
MAXCOLA) + 1 MAXCOLA) + 1
cola.Final ← fin cola.Frente ← ini
cola.elementos[fin]←elem elem←cola.elementos[ini]
FIN FIN
21
2) Con listas enlazadas con Punteros
• Usamos dos variables de tipo puntero, frente y final, que
apunten a los nodos que contienen los elementos frente y
final
!
!

" # $ % & $ " ' % ( )

" # $ % & $ " ' % ( )
• ¿Que sucedería si intercambiáramos las posiciones de

frente y final en la lista enlazada?
• Agrupamos las variables frente y final en un registro
TIPOS
TElemento = // cualquier tipo de datos
TPuntero = PUNTERO A TNodo
TNodo = REGISTRO
valor : TElemento
sig : TPuntero
FINREGISTRO
TCola = REGISTRO
Frente : TPuntero
Final : TPuntero
FINREGISTRO
- * + ,
- * +
. / 0 1 2 0 . 3 1 4 5
. / 0 1 2 0 . 3 1 4 5
22
FUNC CrearCola(): TCola PROC DestruirCola(↓↑cola:
TCola)
VARIABLES
Variables
cola:TCola nodo,sgte: TPuntero
INICIO Inicio
cola.Frente := NULO SI(cola.Frente≠NULO) ENTONCES
cola.Final := NULO sgte ← cola.Frente
RESULTADO ← cola MIENTRAS (sgte≠NULO) HACER
FIN nodo ← sgte
sgte ← sgte^.sig
FUNC ColaVacia(↓cola:
ELIMINAR(nodo)
TCola):LÓGICO
FINMIENTRAS
INICIO FINSI
RESULTADO ← cola.Frente ← NULO
cola.Frente = NULO cola.Final ← NULO
FIN FIN
PROC MeterCola(↓↑cola:TCola; PROC SacarCola (↓↑cola:TCola;
↓elem:TElemento) ↑elem:TElemento)
VARIABLES VARIABLES
ptr: TPuntero
Inicio temp : TipoPuntero
ptr ← NUEVO(TNodo) INICIO
ptr^.valor ← elem temp ← cola.Frente
ptr^sig ← NULO elem ← cola.Frente^.valor
SI ColaVacia(cola) cola.Frente ←
ENTONCES cola.Frente^.sig
cola.Frente ← ptr
SI (cola.Frente=NULO)
EN OTRO CASO
cola.Final^.sig ← ptr ENTONCES
FINSI cola.Final ← NULO
cola.Final ← nuevonodo FINSI
FIN ELIMINAR(temp)
FIN
23
Colas. Aplicaciones
Ejemplo: Reconocimiento del lenguaje. L={W$W/W es una cadena que no contiene a$}
Algoritmo Lenguaje_L
DESDE MCola IMPORTA TCola, CrearCola, ColaVacia, SacarCola,
MeterCola, DestruirCola
CONSTANTES
ENTER ← CHR(13)
TIPOS
TElemento = CARÁCTER
VARIABLES
bien : LÓGICO
c1,c2 : TElemento
cola : TCola
INICIO
cola ← CrearCola()
LEER(c1)
MIENTRAS (c1 ≠ ‘$’) HACER
MeterCola(cola,c1)
LEER(c1)
FINMIENTRAS
Colas. Aplicaciones
Leer(c1)
bien ← CIERTO
MIENTRAS (bien ∧ (c1≠ENTER) HACER
SI ColaVacia(cola) ENTONCES
bien ← FALSE
EN OTRO CASO
SacarCola(cola,c2)
SI (c1 ≠c2) ENTONCES
bien ← FALSE
EN OTRO CASO
LEER(c1)
FINSI
FINSI
FINMIENTRAS
SI (bien ∧ ColaVacia(cola)) ENTONCES
Escribir(“Pertenece”)
EN OTRO CASO
Escribir(“No pertenece”)
FINSI
DestruirCola(cola)
FIN Metodología de Programación
24
Listas
• Definición de lista
- Estática
• Implementación
- Dinámica
Listas
• Definición: Una lista es una colección de elementos
homogéneos (del mismo tipo), con una relación lineal entre
ellos.
• Los elementos pueden o no estar ordenados con respecto a

algún valor y se puede acceder a cualquier elemento de la
lista.
• En realidad, las pilas y colas vistas en secciones anteriores
son listas, con algunas restricciones.
25
Listas
Operaciones sobre listas:
Crear
¿Esta vacía?
¿Está llena?
- De forma ordenada
Insertar un elemento
- De forma no ordenada
Eliminar un elemento
Imprimir
Destruir
Listas
MÓDULO Mlistas
DEFINICIÓN
TIPOS
TElemento =// cualquier tipo de datos
TLista = // por definir
FUNC CrearLista():TLista
FUNC ListaVacia(↓lista:TLista): LÓGICO
FUNC ListaLlena(↓lista:TLista): LÓGICO
PROC InsertarLista(↓↑lista:TLista; ↓elem:TElemento)
PROC EliminarLista(↓↑Lista:TLista; ↓elem:TElemento)
PROC ImprimirLista(lista:TLista)
PROC DestruirLista(↓↑lista: TLista)
IMPLEMENTACIÓN
..............
Fin
26
Listas
• Implementación:
– Representación secuencial
- Dinámica
– Representación enlazada
- Estática
Listas
Dinámicas
• Utilizaremos punteros para crear la lista enlazada de

elementos.
• Las definiciones de tipos y la implementación de las

operaciones se han visto.
27
Listas
Estáticas
• Array de registros:
• Elemento.
• Enlace al siguiente elemento.
• Los registros pueden almacenarse en cualquier orden

físico y se enlazarán a través del campo enlace.
28
Listas
• Inconveniente Variable estática Elección de Tamaño Máximo
• Debemos escribir nuestros propios algoritmos de manejo de memoria
No disponemos de NUEVO y ELIMINAR.

ELIMINAR
• En el array de registros coexistirán dos listas:

- Nuestra lista enlazada de elementos.
- Una lista enlazada con el espacio libre disponible.
Listas
29
Listas
Consideraciones
• El cero (o cualquier otro valor distinto de [1..10]) hará las
funciones de NULO en las listas enlazadas con punteros.
• Cuando no existe ningún elemento en la lista (lista vacía)
sólo existirá la lista libre, que enlaza todas las posiciones
del array.
• Si la lista se llena, no tendremos lista libre.
• Para simular el manejo de memoria real mediante
asignación dinámica de memoria, consideramos el array y
la variable Libre como globales al módulo de
implementación de la lista.
MÓDULO Mlistas
DEFINICIÓN
CONSTANTES
VALOR_NULO ← 0 // Hace las funciones de NULO
MAX ← 100
TIPOS
TLista = [0..Max]
TElemento = // cualquier tipo de datos
TNodo = REGISTRO
elemento : TElemento
sig : TLista
FINREGISTRO
PROC ListaLlena(↓lista: TLista): LÓGICO
PROC ImprimirLista(↓lista: TLista)
PROC InsertarLista(↓↑lista:TLista; ↓elem:TElemento)
PROC EliminarLista(↓↑lista:TLista; ↓elem:TElemento)
PROC DestruirLista(↓↑lista:TLista)
30
IMPLEMENTACIÓN
TIPOS
TMemoria = ARRAY [1..MAX] DE TNodo
VARIABLES
memoria : TMemoria
libre : TLista
INICIO
RESULTADO ← VALOR_NULO
FIN

INICIO
RESULTADO ← (lista = VALOR_NULO)
FIN
FUNC ListaLlena(↓lista:TLista):LÓGICO
INICIO
RESULTADO ← (libre = VALOR_NULO)
FIN
Para los procedimientos NUEVO y ELIMINAR,

ELIMINAR
necesitamos antes implementar las operaciones
(NuevoNodo, EliminarNodo) equivalentes a las que
usamos al trabajar con memoria dinámica.
FUNC NuevoNodo(): Tlista

VARIABLES
ptr: TLista
INICIO
ptr ← libre
SI (ptr ≠ Nulo) ENTONCES
libre ← memoria[ptr]. sig
FINSI
RESULTADO ← ptr
FIN
PROC EliminarNodo (↓↑p : TLista)
INICIO
memoria[p].sig ← libre
lbre ← p
p ← VALOR_NULO
FIN
31
PROC ImprimirLista(↓lista : TLista)
VARIABLES
ptr : TLista
D
ep
INICIO
en
ptr ← lista
de
de
MIENTRAS (ptr ≠ VALOR_NULO) HACER
TE
le
Escribir(memoria[ptr].elemento)
m
en
ptr ← memoria[ptr].sig
to
FINMIENTRAS
FIN
PROC InsertarLista(↓↑lista: TLista; ↓elem: TElemento)
VARIABLES
ptr : TLista
INICIO
ptr ← NuevoNodo()
SI (ptr ≠ VALOR_NULO) ENTONCES
memoria[ptr].elemento ← elem
memoria[ptr].sig ← lista
lista ← ptr
FINSI
FIN
PROC EliminarLista (↓↑lista: TLista; ↓elem :TElemento)

VARIABLES
pav, pret : TLista
Suponemos que el
INICIO
elemento a borrar
pav ← lista // puntero avanzado está en la lista
pret ← Nulo // puntero retrasado
MIENTRAS (memoria[pav].elemento ≠ elem) HACER
pret ← pav
pav ← memoria[pav].sig
FINMIENTRAS
SI (pret = VALOR_NULO) ENTONCES
lista ← memoria[lista].sig
EN OTRO CASO
memoria[pret].sig ← memoria[pav].sig
FINSI
EliminarNodo(pav)
Fin
32
PROC DestruirLista(↓↑lista: TLista)
Variables
aux: TLista
INICIO
MIENTRAS (lista ≠ VALOR_NULO) HACER
aux ← lista
lista ← memoria[lista].sig
EliminarNodo(aux)
FIN
FIN
INICIO // Mlista
Libre ← 1
PARA ptr ← 1 HASTA (Max-1) HACER
memoria[ptr].sig ← ptr + 1
FINPARA
memoria[Max].enlace ← VALOR_NULO
FIN // Mlista
Listas enlazadas circulares

• Implementación estática o dinámica.
• El campo de enlace del último nodo apunta al primer nodo

de la lista, en lugar de tener el valor NULO.
• No existe ni primer ni último nodo. Tenemos un anillo de

elementos enlazados unos con otros.
33
• Es conveniente, aunque no necesario, tener un enlace

(puntero o índice) al último nodo lógico de la lista. Así
podemos acceder facilmente a ambos extremos de la
misma.
• Una lista circular vacía vendrá representada por un valor

NULO (o VALOR_NULO).

Ejemplo: (usando una implementación estática)
PROC ImprimirLista(↓lista:TLista)
VARIABLES
ptr : TLista
INICIO
ptr ← lista
SI (ptr ≠ VALOR_NULO) ENTONCES
REPETIR
Escribir(memoria[ptr].elemento)
ptr ← memoria[ptr].sig
HASTA QUE ptr = lista
FINSI
Fin
34
• Con una lista enlazada circular es muy fácil implementar
una Cola, sin tener que disponer de un registro con dos
campos para el frente y para el final.
Frente Final
Implementación
Listas doblemente
enlazadas
• Es una lista enlazada en la que cada nodo tiene al menos
tres campos:
- Elemento. El dato de la lista.
- Enlace al nodo anterior.
- Enlace al nodo siguiente.
• Los algoritmos para las operaciones sobre listas
doblemente enlazadas son normalmente más complicados.
• Pueden ser recorridas fácilmente en ambos sentidos.
lista
Implementación
35
Listas doblemente
enlazadas
• Una lista doblemente enlazada puede modificarse para
obtener una estructura circular de la misma
lista
Implementación
Listas
NIVEL DE UTILIZACIÓN
• Estructura muy utilizada.
• Ejemplo:
Manejo de tablas hash con el método de encadenamiento para
el tratamiento de sinónimos.
– Utilizaríamos un array de listas como tabla hash. (Lo que en el
primer tema se llamó Encadenamiento)
– Las listas tienen como elementos cadenas de caracteres.
36
Modulo Mhash
DEFINICIÓN
DESDE MLista IMPORTA Tlista
CONSTANTES
MAXCAD ← 20
MAXELE ← 100
TIPOS
TCadena = ARRAY [0..MAXCAD-1] DE CARÁCTER
TElemento = TCadena
TRango = [0.. MAXELE-1]
TTablaHash= ARRAY TRango DE TLista
PROC Almacenamiento(↓↑tabla:TTablaHash; ↓dato:TElemento)
FUNC Búsqueda(↓tabla:TTablaHash; ↓dato:TElemento):LÓGICO
PROC Eliminación(↓↑tabla:TTablaHash; ↓dato:TElemento)
IMPLEMENTACIÓN
PROC Almacenamiento(↓↑tabla:TTablaHash; ↓dato:TElemento)

INICIO
Insertar(tabla[Hash(dato)],dato)
FIN
FUNC Búsqueda(↓tabla:TTablaHash; ↓dato:TElemento):LÓGICO

INICIO
RESULTADO ← Buscar(tabla[Hash(dato)],dato)
FIN
PROC Eliminación(↓↑tabla:TTablaHash; ↓dato:TElemento)

INICIO
Eliminar(tabla[Hash(dato)],dato)
FIN
Fin (* Mhash *)
37
Árboles binarios
• Definición: es un conjunto finito de elementos que está
vacío o está partido en tres subconjuntos disjuntos.
– El primer subconjunto contiene un único elemento llamado
la raíz del árbol binario.
– Los otros dos subconjuntos son a su vez árboles binarios,
llamados subárboles izquierdo y derecho.
derecho
• El subárbol izquierdo o derecho puede estar vacío.
• Cada elemento de un árbol binario se denomina nodo.

nodo
Árboles binarios
• Un método convencional para representar gráficamente un
árbol binario es:
• Consta de 9 nodos.
A • A es el nodo raiz.
• El subárbol izquierdo tiene
como nodo raiz B.
B C
• El subárbol derecho tiene C
como raiz.
D E F • La ausencia de ramas indica
un árbol vacío.
G H I
38
Árboles binarios
• Si A es la raíz de un árbol binario y B es la raíz de su subárbol izquierdo o
derecho, se dice que A es el padre de B y B es el hijo izquierdo o
derecho de A.
• Un nodo que no tiene hijos se denomina nodo hoja.

hoja
• Un nodo n1 es un antecesor de un nodo n2 (y n2 es un descendiente de

n1 si n1 es el padre de n2 o el padre de algún antecesor de n2.
n1) n2
• Un nodo n2 es un descendiente izquierdo de un nodo n1 si n2 es el hijo

izquierdo de n1 o un descendiente del hijo izquierdo de n1. n1 Un
descendiente derecho se puede definir de forma similar.
• Dos nodos son hermanos si son los hijos izquierdo y derecho del mismo
padre.
Árboles binarios
• Árbol estrictamente binario:
binario árbol binario en que cada nodo
no-hoja tiene subárboles izquierdo y derecho no vacíos.
• Nivel de un nodo en un árbol binario:
binario La raíz tiene nivel 0, y
el nivel de cualquier otro nodo en el árbol es uno más que el
nivel de su padre.
• Profundidad de un árbol binario:
binario máximo nivel de cualquier
hoja del árbol.
la longitud del camino más largo
desde la raiz hasta una hoja.
• Árbol binario completo de profundidad d: árbol estrictamente
binario con todas sus hojas con nivel d.
39
Árboles binarios
Un árbol binario contiene m nodos en el nivel L.
Contiene como máximo 2m Puede contener como máximo

nodos en el nivel L+1. 2L nodos en el nivel L
El número total de nodos en un árbol

Un árbol binario completo de binario completo de profundidad d
profunfidad d contiene es:
exactamente 2L nodos en cada
nivel L, entre 0 y d tn = 20 + 21 + 22 + ... + 2d = 2d+1 - 1
Árboles binarios
Árbol ternario: conjunto finito de elementos que está vacío o
está partido en cuatro subconjuntos disjuntos.
– El primer subconjunto contiene un único elemento llamado la raíz del
árbol.
– Los otros tres subconjuntos son a su vez árboles.
Árbol n-ario: conjunto finito de elementos que está vacío o está

partido en n+1 subconjuntos disjuntos.
– El primer subconjunto contiene un único elemento llamado la raíz del
árbol.
– Los otros n subconjuntos son a su vez árboles.
40
Árboles binarios
Operaciones sobre árboles:
¿Esta vacío?
Crear árbol vacío
¿Está lleno?
Crear árbol dada su raíz,
Devolver el contenido del nodo raíz
y sus hijos derecho
Devolver el subárbol derecho
e Izquierdo
Devolver el subárbol derecho
Destruir
Módulo MArbolBin
Imp
DEFINICIÓN lem
e
TIPOS diná ntación
mic
TElemento = // Cualquier tipo de datos a
TArbolBin = PUNTERO A TNodoArbolBin
TNodoArbolBin = REGISTRO
dato : TElemento
izq,der : TArbolBin
FINREGISTRO
FUNC CrearArbolVacio():TArbolBin
FUNC CrearArbol(↓raiz:TElemento;↓izq, ↓dch: TArbolBin
): TArbolBin
FUNC ArbolVacio(↓arbol:TArbolBin):LÓGICO
FUNC Info(↓arbol:TArbolBin):TElemento
FUNC Izq(↓arbol:TArbolBin): TArbolBin
FUNC Der(↓arbol: TArbolBin): TArbolBin
PROC DestruirArbol(↓↑arbol: TArbolBin)
41
IMPLEMENTACIÓN
INICIO
RESULTADO ← NULO
FIN

): TArbolBin
VARIABLES
arbol : TArbolBin
INICIO
arbol ← NUEVO(TNodoArbolBin)
arbol^.dato ← raiz
arbol^.izq ← izq
arbol^.der ← dch
RESULTADO ← arbol
FIN
INICIO
RESULTADO ← (arbol = NULO)
FIN
INICIO
RESULTADO ← arbol^.dato
FIN

INICIO
RESULTADO ← arbol^.izq
FIN

INICIO
RESULTADO ← arbol^.der
FIN
42
INICIO
SI (¬ArbolVacio(arbol)) ENTONCES
DestruirArbol(arbol^.der)
DestruirArbol(arbol^.izq)
ELIMINAR(arbol)
FINSI
FIN
FIN // MArbolBin
Módulo MArbolBinEstático
Im
DEFINICIÖN Se deja propuesto comoplem
CONSTANTES
est entac
ejercicio la de los procedimientos
VALOR_NULO ← 0 átic ión
MAX ← 100
y funciones para una implementación
a
TIPOS estática de un arbol binario
TArbolBin = [0..MAX]
TNodoArbolBin = REGISTRO
dato : TElemento
izq,der : TArbolBin
FINREGISTRO
): TArbolBin
43
Árboles binarios
NIVEL DE UTILIZACIÓN
• Estructura de datos muy útil cuando se deben tomar decisiones de "dos
caminos”
• Muy utilizado en aplicaciones relacionadas con expresiones
aritméticas.
(12-3)*(4+1) *
Ejemplos:
5+2
- +
+
12 3 4 1
5 2
Árboles binarios
Ejemplo: Diseñemos un algoritmo para evaluar una expresión
aritmética que está almacenada en un árbol binario.
Tipos
TipoDecision = (Operador, Operando)
TElemento = REGISTRO
CASO contenido:TipoDecision SEA
Operador:
oper: CARÁCTER
Operando:
val: REAL
FINCASO
FINREGISTRO
44
FUNC Eval(↓arbol:TArbolBin):REAL
VARIABLES
dato:TElemento;
result: REAL
INICIO
dato ← Info(arbol)
SI (dato.contenido = Operando) ENTONCES
result ← dato.val
EN OTRO CASO
CASO dato.oper SEA
'+': result ← Eval(Izq(arbol))+Eval(Der(arbol))
'-': result ← Eval(Izq(arbol))-Eval(Der(arbol))
'*': result ← Eval(Izq(arbol))*Eval(Der(arbol))
'/': result ← Eval(Izq(arbol))/Eval(Der(arbol))
FINCASO
FINSI
RESULTADO ← result
Fin
Árboles binarios de
búsqueda
La estructura lista enlazada es lineal ¿Búsqueda?
La estructura árbol ¿Búsqueda más eficiente?
Siempre que los datos se

distribuyan de forma adecuada
Árbol binario de búsqueda

45
búsqueda
• Definición: árbol binario en el que el subárbol
izquierdo de cualquier nodo (si no está vacío) contiene
valores menores que el que contiene dicho nodo, y el
subárbol derecho (si no está vacío) contiene valores
mayores.
E
Ejemplo: B H
A D F I
C G
búsqueda
Operaciones:
Crear
Buscar Las definidas para un
Insertar
+ árbol binario general
Suprimir
Imprimir
46
Módulo MABB
Definición
TIPOS
TRecorrido = (InOrden,PreOrden,PostOrden)
TClave = ENTERO
clave:TClave
.........
FINREGISTRO
TABB = PUNTERO A TNodoABB
TNodoABB = REGISTRO
izq,der:TABB
elem:TElemento
FINREGISTRO
// Operaciones típicas de los árboles
FUNC CrearABB():TABB
FUNC ABBVacio(↓arbol:TABB):LÓGICO
FUNC InfoABB(↓arbol:TABB):TElemento
FUNC IzqABB(↓arbol:TABB): TABB
FUNC DerABB(↓arbol: TABB): TABB
PROC DestruirABB(↓↑arbol: TABB)
// Operaciones Exclusivas de los árboles binarios de búsqueda

PROC BuscarABB(↓arbol:TABB; ↓c:TClave; ↑dato:TElemento;
↑EnArbol:LÓGICO)
PROC InsertarABB(↓↑arbol:TABB; ↓dato:TElemento)
PROC SuprimirABB(↓↑arbol:TABB; ↓c:TClave)
PROC ImprimirABB(↓arbol:TABB; ↓rec:TRecorrido)
IMPLEMENTACIÓN
FUNC CrearABB():TABB
INICIO
RESULTADO ← NULO
FIN
FUNC ABBVacio(↓arbol:TABB):LÓGICO
INICIO
RESULTADO ← (arbol = NULO)
FIN
FUNC InfoABB(↓arbol:TABB):TElemento
INICIO
RESULTADO ← arbol^.dato
FIN
47
FUNC IzqABB(↓arbol:TABB): TABB
INICIO
RESULTADO ← arbol^.izq
FIN
FUNC DerABB(↓arbol: TABB): TABB

INICIO
RESULTADO ← arbol^.der
FIN
PROC DestruirABB(↓↑arbol: TABB)

INICIO
DestruirABB(arbol^.izq)
DestruirABB(arbol^.dch)
ELIMINAR(arbol)
FIN

↑EnArbol:LÓGICO)
// Solución Iterativa
VARIABLES
ptrArbol: TABB
ele:TElemento
INICIO
EnArbol ← FALSO
ptrArbol ← arbol
MIENTRAS ((¬ABBVacio(ptrArbol)) ∧ (¬EnArbol)) HACER
ele = InfoABB(ptrArbol)
SI (ele.clave = c) ENTONCES
EnArbol ← CIERTO
dato ← ele
SINO SI (c < ele.clave) ENTONCES
ptrArbol ← IzqABB(ptrArbol)
EN OTRO CASO
ptrArbol ← DechABB(ptrArbol)
FINSI
FINMIENTRAS
FIN
48
↑EnArbol:LÓGICO)
// Solución Recursiva
VARIABLES
ele:TElemento
INICIO
SI (ABBVacio(arbol)) ENTONCES
EnArbol ← FALSO
EN OTRO CASO
ele = InfoABB(arbol)
EnArbol ← CIERTO
dato ← ele
SINO SI (c < ele.clave ) ENTONCES
BuscarABB(IzqABB(arbol),c,dato,EnArbol)
EN OTRO CASO
BuscarABB(DechABB(arbol),c,dato,EnArbol)
FINSI
FINSI
FIN
búsqueda
Consideraciones acerca de la operación de inserción.
D A
Entrada: ABCDEFG
B
B F C
D
A C E G
B E
F
Entrada: DBFACEG A D
G
C G
Los mismos datos, insertados en orden

diferente, producirán árboles con F
formas o distribuciones de elementos Entrada: BADCGFE
muy distintas. E
49
búsqueda
// Solución Iterativa
VARIABLES
nuevonodo,pav,pret:TABB
clavenueva:Tclave
ele:TElemento
Inicio
nuevonodo ← NUEVO(TNodoABB)
nuevonodo^.izq ← NULO
nuevonodo^.der ← NULO
nuevonodo^.elem ← dato
clavenueva ← dato.clave
Los ← arbol
pavmismos datos, insertados en orden Avanzado
// Puntero
diferente,
pret ←producirán
NULO árboles
// con
Puntero Retrasado
formas o distribuciones de elementos
muy distintas.
búsqueda
MIENTRAS (pav ≠ NULO) HACER
pret ← pav
ele = pav^.elem
SI (clavenueva < ele.clave ) ENTONCES
pav ← pav^.izq // Voy hacia el hijo izquierdo
EN OTRO CASO
pav ← pav^.dch // Voy hacia el hijo derecho
FINSI
FINMIENTRAS
ele = pret^.elem
SI (clavenueva < ele.clave ) ENTONCES
pret ^.izq ← nuevonodo // Inserto en el hijo izquierdo
EN OTRO CASO
pret ^.dch ← nuevonodo // Inserto en el hijo izquierdo
FINSI
FIN
50
búsqueda
VARIABLES
ele:TElemento ¿Por qué usamos arbol^.izq
INICIO // Solución Recursiva
y arbol^.dch en vez de
arbol ← NUEVO(TNodoABB) IzqABB(arbol) y
arbol^.izq ← NULO DechABB(arbol?
arbol^.der ← NULO
arbol^.elem ← dato
EN OTRO CASO
SI (dato.clave < ele.clave) ENTONCES
InsertarABB(arbol^.izq, dato)
EN OTRO CASO
Los mismos datos,InsertarABB(arbol^.dch,
insertados en orden dato)
FINSI
diferente, producirán árboles con
FINSI
formas o distribuciones de elementos
FIN
muy distintas.
búsqueda
Consideraciones acerca de la operación de suprimir.
• Pasos:
1) Encontrar el nodo a suprimir. Equivalente a Buscar
2) Eliminarlo del árbol. 3 casos
padre de x ex-padre de x
Caso 1
x
51
búsqueda
padre de x ex-padre de x
x
Caso 2
ex-hijo de x
hijo de x
J
J
Q
Eliminar Q
B
B P
L R
L R
Z z Caso 3
K N
K N
M P
M

VARIABLES // Solución Iterativa
pav,pret:TABB
INICIO
pav ← arbol
pret ← NULO //Busco el elemento
MIENTRAS (pav ≠ NULO) ∧ (pav^.elem.clave ≠ c) HACER
pret ← pav
SI (c < pav^.elem.clave) ENTONCES
pav ← pav^.izq
EN OTRO CASO
pav ← pav^.der
FINSI
FINMIENTRAS
SI (pav = NULO) ENTONCES
// No hacer Nada, ya que no hay nada que borrar
SINO SI (pav = arbol) ENTONCES // equivalente a: (pret = NULO)
SuprimirNodo(arbol)
SINO SI (pret^.izq = pav) ENTONCES
SuprimirNodo(pret^.izq)
EN OTRO CASO
SuprimirNodo(pret^.der)
FINSI
FIN
52
PROC SuprimirNodo(↓↑arbol:TABB)
Variables // Solución Iterativa
temp,ant:TABB 0 o 1 hijo
Inicio
temp ← arbol
SI (arbol^.der = NULO) ENTONCES
arbol ← arbol^.izq // Casos sin Hijos ó sin Hijo derecho
SINO SI (arbol^.izq = NULO) ENTONCES 1 hijo
arbol ← arbol^.der // Caso de Sólo Hijo derecho
EN OTRO CASO // Caso Hijos derecho y izquierdo
2 hijos
temp ← arbol^.izq // Busco el mayor hijo derecho del hijo izquierdo
ant ← arbol
MIENTRAS (temp^.der <> NULO) HACER
anterior ← temp
temp ← temp^.der
FINMIENTRAS
arbol^.elem ← temp^.elem
SI (anterior = arbol) ENTONCES
anterior^.izq ← temp^.izq
EN OTRO CASO
anterior^.der ← temp^.izq
FINSI
FINSI
ELIMINAR(temp)

// Solución Recursiva
VARIABLES
ele:TElemento
INICIO
// No hacer Nada, ya que no hay nada que borrar
EN OTRO CASO
SuprimirNodo(arbol)
SINO SI (c < ele.clave ) ENTONCES
SuprimirABB(arbol^.izq,c)
EN OTRO CASO
SuprimirABB(arbol^.dch,c)
FINSI
FINSI ¿Por qué usamos arbol^.izq
FIN
y arbol^.dch en vez de
IzqABB(arbol) y
DechABB(arbol? ?
53
PROC SuprimirNodo(↓↑arbol:TABB) // Solución Recursiva
Variables
temp:TABB 0 o 1 hijo
ele :TElemento
FUNC MayorHijoDerecho(↓arbol:TipoABBúsqueda):TElemento
INICIO // Solución Recursiva
SI (ABBVacio(DchABB(arbol))) ENTONCES
RESULTADO ← InfoABB(arbol)
EN OTRO CASO 1 hijo
RESULTADO ← MayorHijoDerecho(DchABB(arbol))
FINSI
FIN
INICIO
SI (arbol^.der = NULO) ENTONCES
temp ← arbol
arbol ← arbol^.izq// Casos sin Hijos ó sin Hijo derecho
ELIMINAR(temp)
SINO SI (arbol^.izq = NULO) ENTONCES
temp ← arbol
arbol ← arbol^.der// Caso de Sólo Hijo derecho
ELIMINAR(temp)
EN OTRO CASO // Caso Hijos derecho y izquierdo
ele ← MayorHijoDerecho(IzqABB(arbol))
arbol^.elem ← ele
SuprimirABB(arbol^.izq,ele.clave)
FINSI
búsqueda
Consideraciones acerca de la operación de imprimir.
• Recorrer un árbol es "visitar" todos sus nodos para llevar a

cabo algún proceso como por ejemplo imprimir los
elementos que contiene.
• ¿Cómo imprimir los elementos de un árbol? ¿en qué

orden?.
54
búsqueda
• Para recorrer un árbol binario en general (de búsqueda o no), podemos
hacerlo de tres formas distintas:
a) Recorrido InOrden.
1) Recorrer el subárbol izquierdo en InOrden
Pasos: 2) "Visitar" el valor del nodo raiz y procesarlo
3) Recorrer el subárbol derecho en InOrden
b) Recorrido PreOrden.
1) "Visitar" el valor del nodo raiz y procesarlo
Pasos: 2) Recorrer el subárbol izquierdo en PreOrden
3) Recorrer el subárbol derecho en PreOrden
c) Recorrido PostOrden.
1) Recorrer el subárbol izquierdo en PostOrden
Pasos: 2) Recorrer el subárbol derecho en PostOrden
3) "Visitar" el valor del nodo raiz y procesarlo
PROC Imp_InOrden(↓arbol:TABB)
INICIO
SI (¬ABBVacio(arbol)) ENTONCES
Imp_InOrden(IzqABB(arbol))
ImpNodo(InfoABB(arbol))
Imp_InOrden(DerABB(arbol))
FINSI
FIN
PROC Imp_PreOrden(↓arbol:TABB)
INICIO
Imp_PreOrden(IzqABB(arbol))
Imp_PreOrden(DerABB(arbol))
FINSI
FIN
55
PROC Imp_PostOrden(↓arbol:TABB)
INICIO
Imp_PostOrden(IzqABB(arbol))
Imp_PostOrden(DchABB(arbol))
FINSI
Fin
PROC ImprimirABB(↓arbol:TABB; ↓rec:TRecorrido)

Inicio
CASE rec SEA
inorden: Imp_InOrden(arbol)
preorden: Imp_PreOrden(arbol)
postorden: Imp_PostOrden(arbol)
FINCASO
Fin
Fin (* MArbolBinarioBusqueda *)
búsqueda
Ejemplo: P
F S
Y
B H R
T Z
G
W
• El recorrido InOrden mostraría: BFGHPRSTWYZ

• El recorrido PreOrden: PFBHGSRYTWZ
• El recorrido PostOrden: BGHFRWTZYSP
56
búsqueda
Nivel de utilización
• Aplicaciones en las que estén implicas operaciones
de búsqueda de elementos
• Ejemplo: Supongamos que deseamos implementar
un diccionario inglés/español en que la búsqueda de
la traducción de una palabra inglesa sea rápida. Para
ello podemos usar un árbol binario de búsqueda en
el que el tipo elemento sea un registro con la palabra
en inglés (que será la clave) y la palabra en español.
búsqueda
ALGORITMO Diccionario
DESE MABB IMPORTA TABB, CrearABB, DestruirABB, BuscarABB,
InsertarABB, SuprimirABB, ImprimirABB
CONSTANTES
MAXCAD = 20
TIPOS
TCadena = ARRAY [0..MAXCAD-1] DE CARÁCTER
TDic = TABB
Tclave = TCadena
clave:TClave // Palabra inglés
traducción: TCadena // Palabra Español
FINREGISTRO
57
búsqueda
PROC InsPalDic(↓↑d:Tdic; ↓pal: TElemento)
INICIO
InsertarABB(d,pal)
FIN
PROC BuscaPalDic(↓d:TDic; ↓inglés:TClave ; ↑pal: TElemento;

↑encontrado:LÓGICO)
INICIO
BuscarABB(d,inglés,pal,encontrado)
FIN
PROC BorrarPalDic(↓↑d:TDic; ↓inglés:TClave)

INICIO
SuprimirABB(d,inglés)
FIN
Bibliografía
6 7 8 9 : ; < = > ? 8 9 : ; @ A B : C : : D @ E F G F H I J K I L M
J O P Q K O Q P I J R S T I O U J F E V W X Y Z [ ; Z \ ] \ ^ Y F _ ] ` a [ b c
\ e e f C Y g V a [ h V a \ ] [ Y [ Z V ; i j [ k [ @ l = < = F
H P U p P I q I K r s t S t u v v w
6 7 m n D 9 o o ? m n D 9 A ; E @ : F
x
d
L p U P r O q U J y S J O P Q K O Q P I J R S R I O U J M U z { S O U J w
_ ] ` a [ b \ e e @
o o o F
6 7 E 9 } C o o ? E 9 } C G @ ~ F S J U L Q K r s t R S P U z L S q I J K U t
|
d
u v v w E V W X Y Z [ ; Z \ ] \ ^ Y F a V Y g \ ] V [ e e @ o o o F
6 7 E n o l ? E n E @ F L L S t p Q I { S R S
P U p P I q I K r s t u v v F ; Z \ ] \ ^ Y ; i j V ] \ [ e @ 9 Z \ i i Y c ~ V i e V B @
o o l F
58

Estructura de Datos Avanzada PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Estructura de Datos Avanzada PDF

Transféré par

Droits d'auteur :

Formats disponibles

Estructuras de Datos

eliminar elementos, SÓLO a

• Estructura LIFO (L Last Input

Sólo es posible acceder a la Cabeza de la Pila

¿ Cómo es posible conocer la posición de la cabeza?

1) Variable entera “cabeza” Inconveniente: se ha de pasar

• Inconveniente: Solo es posible implementar una pila de

DESDE MPila IMPORTA TPila, CrearPila, MeterPila, SacarPila,

• Utilizar un indice para el frente y otro para el final y

• Ventaja: operación Sacar más sencilla

¿Como saber si la cola está llena? Es necesario que la posición a la

• Crear la cola (inicializarla vacía): frente =Maxcola (índice

" # $ % & $ " ' % ( )

• ¿Que sucedería si intercambiáramos las posiciones de

• Los elementos pueden o no estar ordenados con respecto a

• Utilizaremos punteros para crear la lista enlazada de

• Las definiciones de tipos y la implementación de las

• Los registros pueden almacenarse en cualquier orden

• Inconveniente Variable estática Elección de Tamaño Máximo

• Debemos escribir nuestros propios algoritmos de manejo de memoria

No disponemos de NUEVO y ELIMINAR.

• En el array de registros coexistirán dos listas:

FUNC ListaVacia(↓lista:TLista): LÓGICO

Para los procedimientos NUEVO y ELIMINAR,

FUNC NuevoNodo(): Tlista

PROC EliminarLista (↓↑lista: TLista; ↓elem :TElemento)

Listas enlazadas circulares

• El campo de enlace del último nodo apunta al primer nodo

• No existe ni primer ni último nodo. Tenemos un anillo de

• Es conveniente, aunque no necesario, tener un enlace

• Una lista circular vacía vendrá representada por un valor

Listas enlazadas circulares

• Estructura muy utilizada.

PROC Almacenamiento(↓↑tabla:TTablaHash; ↓dato:TElemento)

FUNC Búsqueda(↓tabla:TTablaHash; ↓dato:TElemento):LÓGICO

PROC Eliminación(↓↑tabla:TTablaHash; ↓dato:TElemento)

PROC Almacenamiento(↓↑tabla:TTablaHash; ↓dato:TElemento)

FUNC Búsqueda(↓tabla:TTablaHash; ↓dato:TElemento):LÓGICO

PROC Eliminación(↓↑tabla:TTablaHash; ↓dato:TElemento)

• El subárbol izquierdo o derecho puede estar vacío.

• Cada elemento de un árbol binario se denomina nodo.

• Un nodo que no tiene hijos se denomina nodo hoja.

• Un nodo n1 es un antecesor de un nodo n2 (y n2 es un descendiente de

• Un nodo n2 es un descendiente izquierdo de un nodo n1 si n2 es el hijo

Un árbol binario contiene m nodos en el nivel L.

Contiene como máximo 2m Puede contener como máximo

El número total de nodos en un árbol

Árbol n-ario: conjunto finito de elementos que está vacío o está

FUNC CrearArbol(↓raiz:TElemento;↓izq, ↓dch: TArbolBin

FUNC Izq(↓arbol:TArbolBin): TArbolBin

FUNC Der(↓arbol: TArbolBin): TArbolBin

La estructura lista enlazada es lineal ¿Búsqueda?

La estructura árbol ¿Búsqueda más eficiente?

Siempre que los datos se

Árbol binario de búsqueda

// Operaciones Exclusivas de los árboles binarios de búsqueda

FUNC DerABB(↓arbol: TABB): TABB

PROC DestruirABB(↓↑arbol: TABB)

PROC BuscarABB(↓arbol:TABB; ↓c:TClave; ↑dato:TElemento;

Los mismos datos, insertados en orden

PROC SuprimirABB(↓↑arbol:TABB; ↓c:TClave)

PROC SuprimirABB(↓↑arbol:TABB; ↓c:TClave)

• Recorrer un árbol es "visitar" todos sus nodos para llevar a