CAPÍTULO 11

Ordenación, búsqueda

y fusión externa (archivos)

11.1. Introducción

11.2. Archivos ordenados

11.3. Fusión de archivos

11.4. Partición de archivos

11.5. Clasificación de archivos

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

CONCEPTOS CLAVE

RESUMEN

EJERCICIOS

Los sistemas de procesamiento de la información procesan normalmente gran cantidad de información. En

estos casos los datos se almacenan sobre soportes de

almacenamiento masivo (cintas y discos magnéticos).

Los algoritmos de ordenación presentados en el Capítulo 10 no son aplicables si la masa de datos no

cabe en la memoria central de la computadora y se

encuentran almacenados en su soporte como una cinta. En estos casos se suelen colocar en memoria central las fichas que se procesan y a las que se pueda

acceder directamente. Normalmente estas técnicas no

son muy eficaces y se utilizan técnicas distintas de

ordenación. La técnica más importante es la fusión o

mezcla.

Este capítulo realiza una introducción a las técnicas

de ordenación, búsqueda y mezcla o fusión externas.

INTRODUCCIÓN

406 Fundamentos de programación

11.1. INTRODUCCIÓN

Cuando la masa de datos a procesar es grande y no cabe en la memoria central de la computadora, los datos se organizan en archivos que, a su vez, se almacenan en dispositivos externos de memoria auxiliar (discos, cintas magnéticas, etc.).

Las operaciones básicas estudiadas en el Capítulo 10, ordenación, búsqueda e intercalación o mezcla, sufren un

cambio importante en su concepción, derivado esencialmente del hecho físico de que los datos a procesar no caben

en la memoria principal de la computadora.

11.2. ARCHIVOS ORDENADOS

El tratamiento de los archivos secuenciales exige que éstos se encuentren ordenados respecto a un campo del registro,

denominado campo clave.

Supongamos un archivo del personal de una empresa, cuya estructura de registros es la siguiente:

NOMBRE

DIRECCION

FECHA

SALARIO

CATEGORIA

DNI

tipo cadena

tipo cadena

tipo cadena

tipo numérico

tipo cadena

tipo cadena

(nombre del empleado)

(dirección)

(fecha de nacimiento)

(salario)

(categoría laboral)

(número de DNI)

La clasificación en orden ascendente o descendente se puede realizar con respecto a una clave (nombre,

dirección, etc.). Sin embargo, puede ser interesante tener clasificado un fichero por categoría laboral y a su vez se

puede tener por cada categoría laboral los registros agrupados por nombres o direcciones. Ello nos lleva a la conclusión de que un archivo puede estar ordenado por un campo clave o una jerarquía de campos.

Se dice que un archivo (estructura del registro: campos C1, C2, ... Cn) está ordenado principalmente por el campo C1, en orden secundario 1 por el campo C2, en orden secundario 2 por el campo C3, etc., en orden secundario n

por el campo Cn. Si el archivo tiene la siguiente organización:

• Los registros aparecen en el archivo según el orden de los valores del campo clave C1.

• Si se considera un mismo valor C1, los registros aparecen en el orden de los valores del campo C2.

• Para un mismo valor de C(Ci

) los registros aparecen según el orden de los valores del campo Ci

+ 1, siendo

1 =< i <= n.

Si se desea ordenar un archivo principalmente por C1, y en orden secundario 1 por C2, se necesita:

• Ordenar primero por C2.

• Ejecutar a continuación una ordenación estable por el campo C1.

La mayoría de los Sistemas Operativos actuales disponen de programas estándar (utilidad) que realizan la clasificación de uno o varios archivos (sort). En el caso del Sistema Operativo MS-DOS existe la orden SORT, que permite realizar la clasificación de archivos según ciertos criterios específicos.

Los algoritmos de clasificación externa son muy numerosos y a ellos dedicaremos gran parte de este capítulo.

11.3. FUSIÓN DE ARCHIVOS

La fusión o mezcla de archivos (merge) consiste en reunir en un archivo los registros de dos o más archivos ordenados por un campo clave T. El archivo resultante será un archivo ordenado por el campo clave T.

Supongamos que se dispone de dos archivos ordenados sobre dos cintas magnéticas y que se desean mezclar o

fundir en un solo archivo ordenado. Sean los archivos F1 y F2 almacenados en dos cintas diferentes. El archivo F3

se construye en una tercera cinta.

Ordenación, búsqueda y fusión externa (archivos) 407

El algoritmo de fusión de archivos será

inicio

//fusión de dos archivos

1. poner archivo 1 en cinta 1, archivo 2 en cinta 2

2. seleccionar de los dos primeros registros de archivo

1 y archivo 2 el registro de clave más pequeña y

almacenarlo en un nuevo archivo 3

3. mientras (archivo 1 no vacio) y (archivo 2 no vacio) hacer

4. seleccionar el registro siguiente con clave mas

pequeña y almacenarlo en el archivo 3

fin_mientras

//uno de los archivos no está aún vacío

5. almacenar resto archivo en archivo 3 registro a registro

fin

EJEMPLO 11.1

Se dispone de dos archivos, F1 y F2, cuyos campos claves son

F1 12 24 36 37 40 52

F2 3 8 9 20

y se desea un archivo FR ordenado, que contenga los dos archivos F1 y F2.

La estructura de los archivos F1 y F2 es:

F1 12 24 36 37 40 52 EOF(*) Fin archivo (eof)

F2 3 8 9 20

Para realizar la fusión de F1 y F2 es preciso acceder a los archivos F1 y F2 que se encuentran en soportes magnéticos en organización secuencial. En cada operación de acceso a un archivo sólo se puede acceder a un único elemento del archivo en un momento dado. Para realizar la operación se utiliza una variable de trabajo del mismo tipo

que los elementos del archivo. Esta variable representa al elemento actual del archivo y denominaremos ventana,

debido a que será la variable que nos permitirá ver el archivo, elemento tras elemento. El archivo se recorre en un

único sentido y su final físico termina con una marca especial denominada fin de archivo (EOF, end of file); por

ejemplo, un asterisco (*).

12

3 8 9 20 *

F1 24 36 37 52 40

Ventana

Ventana

F2

*

Se comparan las claves de las ventanas y se sitúa la más pequeña 3(F2) en el archivo de salida. A continuación,

se avanza un elemento el archivo F2 y se realiza una nueva comparación de los elementos situados en las ventanas.

3 8 9 20 *

Ventana

Ventana

F1 12 24 36 40 52 *

F2

F3 3

408 Fundamentos de programación

Cuando uno u otro de los archivos de entrada se ha terminado, se copia el resto del archivo sobre el archivo de

salida y el resultado final será:

FR 3 8 9 12 20 24 36 37 40 52 *

El algoritmo correspondiente de fusión de archivos será

algoritmo fusion_archivo

var

entero:ventana1, ventana2, ventanaS

archivo_s de entero: F1,F2,F3

//ventana1,ventana2 claves de los archivos F1,F2

ventanaS claves del archivo FR

inicio

abrir (F1, l, 'nombre')

abrir (F2, l, 'nombre2')

crear (FR, 'nombre3')

abrir (FR, e, 'nombre3')

leer (F1, ventana1)

leer (F2, ventana2)

mientras no FDA(F1) y no FDA (F2) hacer

si ventana1 <= ventana2 entonces

ventanaS ← ventana1

escribir(FR,ventanaS)

leer (F1, ventana1)

si_no

ventanaS ← ventana2

escribir (FR, ventanaS)

leer (F2, ventana2)

fin_si

fin_mientras

//lectura terminada de F1 o F2

mientras no FDA (F1) hacer

ventanaS ← ventana1

escribir(FR, ventanaS)

leer(F1, ventana1)

fin_mientras

mientras_no FDA(F2)hacer

ventanaS ← ventana2

escribir (FR, ventanaS)

leer(F2, ventana2)

fin_mientras

cerrar (F1,F2,FR)

fin

Se considera ahora el otro caso posible en los archivo secuenciales. El final físico del archivo se detecta al leer

el último elemento (no la marca de fin de archivo) y los ficheros son de registros con varios campos. El algoritmo

correspondiente a la fusión sería:

tipo

registro: datos_personales

-: C //campo por el que estan ordenados

-:-

fin_registro

archivo_s de datos_personales: arch

Ordenación, búsqueda y fusión externa (archivos) 409

var

datos_personales:r1, r2

arch: f1, f2, f //f es el fichero resultante

lógico: fin1, fin2

inicio

abrir (f1, l, 'nombre1')

abrir (f2, l, 'nombre2')

crear (f, 'nombre3')

abrir (f, e, 'nombre3')

fin1← falso

fin2← falso

si FDA (f1) entonces

fin1← verdad

si-no

leer_reg (f1, r1)

fin_si

si FDA (f2) entonces

fin2← verdad

si_no

leer_reg (f2, r2)

fin_si

mientras NO fin1 y NO fin2 hacer

si r1.c < r2.c entonces

escribir_reg (f, r1)

si FDA (f1) entonces

fin1← verdad

si_no

leer_reg (f1, r1)

fin_si

si_no

escribir_reg (f, r2)

si FDA (f2) entonces

fin2← verdad

si_no

leer_reg (f2,r2)

fin_si

fin_si

fin_mientras

mientras NO fin1 hacer

escribir_reg (f, r1)

si FDA (f1) entonces

fin1← verdad

si_no

leer_reg (f1, r1)

fin_si

fin_mientras

mientras NO fin2 hacer

escribir_reg (f, r2)

si FDA (f2) entonces

fin2← verdad

si_no

leer_reg (f2, r2)

fin_si

fin_mientras

cerrar (f1, f2, f)

fin

410 Fundamentos de programación

11.4. PARTICIÓN DE ARCHIVOS

La partición o división de un archivo consiste en repartir los registros de un archivo en otros dos o más archivos en

función de una determinada condición.

Aunque existen muchos métodos de producir particiones a partir de un archivo no clasificado, consideraremos

sólo los siguientes métodos:

• clasificación interna,

• por el contenido,

• selección por sustitución,

• secuencias.

Supongamos el archivo de entrada siguiente, en el que se indican las claves de los registros:

110 48 33 69 46 2 62 39 28 47 16 19 34 55

99 78 75 40 35 87 10 26 61 92 99 75 11 2

28 16 80 73 18 12 89 50 47 36 67 94 23 15

84 44 53 60 10 39 76 18 24 86

11.4.1. Clasificación interna

El método más sencillo consiste en leer M registros a la vez de un archivo no clasificado, clasificarlos utilizando un

método de clasificación interna y a continuación darles salida como partición. Obsérvese que todas las particiones

producidas de este modo, excepto posiblemente la última, contendrán exactamente M registros. La figura muestra las

particiones producidas a partir del archivo de entrada de la figura utilizada un tamaño de memoria (M) de cinco registros.

33 46 48 69 110

2 28 39 47 62

16 19 34 55 99

35 40 75 78 87

10 26 61 92 99

2 11 16 28 75

12 18 73 80 89

36 47 50 67 94

15 23 44 53 84

10 18 39 60 76

24 86

11.4.2. Partición por contenido

La partición del archivo de entrada se realiza en función del contenido de uno o más campos del registro.

Así, por ejemplo, si se supone un archivo f que se desea dividir en dos archivos f1 y f2, tal que f1 contenga

todos los registros que contengan en el campo clave c, el valor v y en el archivo f2 los restantes registros.

El algoritmo de partición se muestra a continuación:

algoritmo particionå_contenido

....

inicio

abrir (f, l,'nombre')

crear (f1, 'nombre1')

abrir (f1, e, 'nombre1')

Ordenación, búsqueda y fusión externa (archivos) 411

crear (f2, 'nombre2')

abrir ( f2, e, 'nombre2')

leer(v)

mientras NO FDA (f) hacer

leer_reg (f, r)

si v = r.c entonces

escribir_reg (f1,r)

si_no

escribir_reg (f2, r)

fin_si

fin_mientras

cerrar (f, f1, f2)

fin

11.4.3. Selección por sustitución

La clasificación interna vista en el apartado 11.4.1 no tiene en cuenta la ventaja que puede suponer cualquier ordenación parcial que pueda existir en el archivo de entrada. El algoritmo de selección por sustitución tiene en cuenta

tal ordenación. Los pasos a dar para obtener particiones ordenadas son:

1. Leer N registros del archivo desordenado, poniéndolos todos a no congelados.

2. Obtener el registro R con clave más pequeña de entre los no congelados y escribirlo en partición.

3. Sustituir el registro por el siguiente del archivo de entrada. Este registro se congelará si su clave es más pequeña que la del registro R y no se congelará en otro caso. Si hay registro sin congelar volver al paso 2.

4. Comenzar nueva partición. Si se ha llegado a fin de fichero se repite el proceso sin leer.

Nota: Al final de este método los ficheros con las particiones tienen secuencias ordenadas, lo que no quiere decir

que ambos hayan quedado completamente ordenados.

F: 3 31 14 42 10 15 8 13 63 18 50

F1 F2

3 31 14 42 3 13 50 8 18 8

10 31 14 42 10 13 50 8 18 13

15 31 14 42 14 13 50 8 18 18

15 31 8 42 15 13 50 8 18 50

13 31 8 42 31 13 50 8 18

13 63 8 42 42

13 63 8 18 63

13 50 8 18

algoritmo particion_s

const n= <valor>

tipo

registro: datos_personales

<tipo_dato>:c

...

fin_registro

registro: datos

datos_personales: dp

logico : congela

fin_registro

array[1..n] de datos: arr

archivo_s de datos_personales: arch

var

412 Fundamentos de programación

datos_personales: r

arr : a

arch : f1,f2, f

lógico : sw

entero : numcongelados, y, posicionmenor

inicio

abrir(f, l, 'nombre')

crear(f1, 'nombre1')

abrir(f1, e, 'nombre1')

crear(f2,'nombre2')

abrir(f2, e, 'nombre32')

numcongelados ← 0

desde i ← 1 hasta n hacer

si no fda(f) entonces

leer_reg(f, r)

a[i].dp ← r

a[i].congela ← falso

si_no

a[i].congela ← verdad

numcongelados ← numcongelados + 1

fin_si

fin_desde

sw ← verdad

mientras no fda(f) hacer

mientras (numcongelados < n) y no fda(f) hacer

buscar_no_congelado_menor(a, posicionmenor)

si sw entonces

escribir_reg(f1, a[posicionmenor].dp)

si_no

escribir_reg(f2, a[posicionmenor].dp)

fin_si

leer_reg(f, r)

si r.c. > a[posicionmenor].dp.c entonces

a[posicionmenor].dp ← r

si_no

a[posicionmenor].dp ← r

a[posicionmenor].congela ← verdad

numcongelados ← numcongelados + 1

fin_si

fin_mientras

sw ← no sw

descongelar(a)

numcongelados ← 0

fin_mientras

mientras numcongelados < n hacer

buscar_no_congelado_menor(a, posicionmenor)

si sw entonces

escribir_reg(f1,a[posicionmenor].dp)

si_no

escribir_reg(f2, a[posicionmenor].dp)

fin_si

a[posicionmenor].congela ← verdad

numcongelados ← numcongelados + 1

fin_mientras

cerrar(f, f1, f2)

fin

Ordenación, búsqueda y fusión externa (archivos) 413

11.4.4. Partición por secuencias

Los registros se dividen en secuencias alternativas con longitudes iguales o diferentes según los casos.

Las secuencias pueden ser de diferentes diseños:

• El archivo f se divide en dos archivos, f1 y f2, copiando alternativamente en uno y otro archivo secuencias de

registros de longitud m. (Algoritmo particion_1.)

• El archivo f se divide en dos archivos, f1 y f2, de modo que en f1 se copian los registros que ocupan las

posiciones pares y en f2 los registros que ocupan las posiciones impares. (Algoritmo particion_2.)

algoritmo particion_1

tipo

registro: datos personales

<tipodato> : C

..............

fin_registro

archivo_s de datos_personales : arch

var

datos_personales: r

arch : f, f1, f2

lógico : SW

entero : i, n

inicio

abrir (f, l, 'nombre')

crear (f1, 'nombre1')

abrir (f1, e, 'nombre1')

crear (f2, 'nombre2')

abrir (f2, e, 'nombre2')

i← 0

leer (n)

SW← verdad

mientras NO FDA (f) hacer

leer_reg (f,r)

si SW entonces

escribir_reg (f2, r)

si_no

escribir_reg (f2,r)

fin_si

i← i+1

si i = n entonces

SW ← NO SW

i ← 0

fin_si

fin_mientras

cerrar (f, f1, f2)

fin

algoritmo particion_2

tipo

registro: datos_personales

<tipo_dato> : C

...............

fin_registro

archivo_s de datos_personales : arch

var

datos_personales : r

414 Fundamentos de programación

arch : f1, f2, f

lógico : SW

inicio

abrir (f, l, 'nombre')

crear (f1, 'nombre1')

abrir (f1, e, 'nombre1')

crear (f2, 'nombre2')

abrir (f2, e, 'nombre2')

SW← verdad

mientras NO FDA (f) hacer

leer_reg (f, r)

si SW entonces

escribir_reg (f1,r)

si_no

escribir_reg (f2,r)

fin_si

SW← NO SW

fin_mientras

cerrar (f, f1, f2)

fin

11.5. CLASIFICACIÓN DE ARCHIVOS

Los archivos están clasificados en orden ascendente o descendente cuando todos sus registros están ordenados en

sentido ascendente o descendente respecto al valor de un campo determinado, denominado clave de ordenación.

Si el archivo a ordenar cabe en memoria central, se carga en un vector y se realiza una clasificación interna,

transfiriendo a continuación el archivo ordenado al soporte externo o copiando el resultado en el archivo original si

no se desea conservar.

En el caso de que el archivo no quepa en memoria central, la clasificación se realizará sobre el archivo almacenado en un soporte externo. El inconveniente de este tipo de clasificación reside en el tiempo, que será mucho mayor

debido especialmente a las operaciones entrada/salida de información que requiere la clasificación externa.

Los algoritmos de clasificación son muy variados, pero muchos de ellos se basan en procedimientos mixtos consistentes en aprovechar al máximo la capacidad de la memoria central.

Como métodos de clasificación de archivos que no utilizan la memoria central y son aplicables a archivos secuenciales, se tienen la mezcla directa y la mezcla natural.

11.5.1. Clasificación por mezcla directa

El método más fácil de comprender es el denominado mezcla directa. Se analiza su aplicación a través de un breve

ejemplo en el que se aplicará el método sobre un vector. Se puede pensar en los componentes del vector como las

claves de los registros sucesivos del archivo.

El procedimiento consiste en una partición sucesiva del archivo y una fusión que produce secuencias ordenadas.

La primera partición se hace para secuencias de longitud 1 utilizando dos archivos auxiliares y la fusión producirá secuencias ordenadas de longitud 2. A cada nueva partición y fusión se duplicará la longitud de las secuencias

ordenadas. El método terminará cuando la longitud de la secuencia ordenada exceda la longitud del archivo a ordenar.

Consideremos el archivo:

F: 19 27 2 8 36 5 20 15 6

El archivo F se divide en dos nuevos archivos F1 y F2:

F1: 19 2 36 20 6

F2: 27 8 5 15

Ordenación, búsqueda y fusión externa (archivos) 415

Ahora se funden los archivos F1 y F2, formando pares ordenados:

F: 19 27 2 8 5 36 15 20 6

Se vuelve a dividir de nuevo en partes iguales y en secuencias de longitud 2

F1: 19 27 5 36 6

F2: 2 8 15 20

La fusión de los archivos producirá

F: 2 8 19 27 5 15 20 36 6

La nueva partición será

F1: 2 8 19 27 6

F2: 5 15 20 36

La nueva fusión será

F: 2 5 8 15 19 20 27 36 6

Cada operación que trata por completo el conjunto de datos en su totalidad se denomina una fase y el proceso de

ordenación se denomina pasada.

F1: 2 5 8 15 19 20 27 36

F2: 6

F: 2 5 6 8 15 19 20 27 36

Evidentemente, la clave de la clasificación es disminuir el número de pasadas e incrementar su tamaño; una secuencia ordenada es una que contiene sólo una pasada que, a su vez, contiene todos los elementos de la pasada.

EJEMPLO 11.2

Para la implementación de los siguientes algoritmos no se consideró la existencia de un registro especial que indicara el fin de archivo. La función FDA(id_arch) retorna cierto cuando se accede al último registro.

Si se considerase la existencia del registro especial que marca el fin de archivo se podría prescindir del uso de

las variables lógicas fin, fin1, fin2.

algoritmo ord_mezcla_directa

...

procedimiento ordmezcladirecta

var

datos_personales: r,r1,r2

arch : f,f1,f2

// El tipo arch es archivo_s de datos_personales

entero : lgtud, long

lógico : sw,fin1,fin2

entero : i,j

inicio

// calcularlongitud(f) es una función definida por el usuario que

// devuelve el número de registros del archivo original

416 Fundamentos de programación

long ← calcularlogitud(f)

lgtud ← 1

mientras lgtud < long hacer

abrir(f,l,'fd')

crear(f1,'f1d')

crear(f2,'f2d')

abrir(f1,e,'f1d')

abrir(f2,e,'f2d')

i ← 0

sw ← verdad

mientras no FDA(f) hacer

leer_reg(f,r)

si sw entonces

escribir_reg(f1,r)

si_no

escribir_reg(f2,r)

fin_si

i ← i + 1

si i=lgtud entonces

sw ← no sw

i ← 0

fin_si

fin_mientras

cerrar(f,f1,f2)

abrir(f1,l,'f1d')

abrir(f2,l,'f2d')

crear(f,'fd')

abrir (f,e,'fd')

i ← 0

j ← 0

fin1 ← falso

fin2 ← falso

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

mientras no fin1 o no fin2 hacer

mientras no fin1 y no fin2 y (i<lgtud) y (j<lgtud) hacer

si menor(r1,r2) entonces

escribir_reg(f,r1)

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

i ← i + 1

si_no

escribir_reg(f,r2)

si FDA(f2) entonces

fin2 ← verdad

Ordenación, búsqueda y fusión externa (archivos) 417

si_no

leer_reg(f2,r2)

fin_si

j ← j + 1

fin_si

fin_mientras

mientras no fin1 y (i < lgtud) hacer

escribir_reg(f,r1)

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

i ← i + 1

fin_mientras

mientras no fin2 y (j < lgtud) hacer

escribir_reg(f,r2)

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

j ← j + 1

fin_mientras

i ← 0

j ← 0

fin_mientras // del mientras no fin1 o no fin2

cerrar(f,f1,f2)

lgtud ← lgtud*2

fin_mientras // del mientras lgtud < long

borrar('f1d')

borrar('f2d')

fin_procedimiento

11.5.2. Clasificación por mezcla natural

Es uno de los mejores métodos de ordenación de ficheros secuenciales. Consiste en aprovechar la posible ordenación

interna de las secuencias del archivo (F), obteniendo con ellas particiones ordenadas de longitud variable sobre una

serie de archivos auxiliares, en este caso dos, F1 y F2. A partir de estos ficheros auxiliares se escribe un nuevo F

mezclando los segmentos crecientes máximos de cada uno de ellos.

EJEMPLO 11.3

Clasificar el vector

F: 19 27 2 8 36 5 20 15 6

Se divide F en dos vectores F1 y F2, donde se ponen alternativamente los elementos F1 y F2. F está ahora vacío.

Etapa 1, fase 1:

F1: 19 27/ 5 20/ 6

F2: 2 8 36/ 15

Se selecciona el elemento más pequeño de F1 y F2, que pasan a estar en F3.

418 Fundamentos de programación

Etapa 1, fase 2:

F1: 19 27/ 5 20/ 6

F2: 8 36/ 15

F3: 2

Ahora se comparan 8 y 19, se selecciona 8. De modo similar, 19 y 27:

F1: 5 20/ 6

F2: 36/ 15

F3: 2 8 19 27

En F1 se ha interrumpido la secuencia creciente y se continúa con F2 hasta que también en él se termine la secuencia creciente.

F1: 5 20/ 6

F2: 15

F3: 2 8 19 27 36

Ahora 5 y 15 son menores que 36. Finalmente se tendrá

F3: 2 8 19 27 36/ 5 15 20/ 6

F1 y F2 están ahora vacíos.

Etapa 2, fase 1:

Dividir F3 en dos

F1: 2 8 19 27 36/ 6

F2: 5 15 20

Etapa 2, fase 2:

Se mezclan F1 y F2

F3: 2 5 8 15 19 20 27 36 6

Etapa 3, fase 1:

F1: 2 5 8 15 19 20 27 36

F2: 6

Etapa 3, fase 2:

F3: 2 5 6 8 15 19 20 27 36

y el archivo F3 ya está ordenado.

Algoritmo

algoritmo ord_mezcla_natural

...

procedimiento ordmezclanatural

var

datos_personales: r,r1,r2,ant,ant1,ant2

arch : f,f1,f2

//El tipo arch es archivo_s de datos_personales

Ordenación, búsqueda y fusión externa (archivos) 419

lógico : ordenado,crece,fin,fin1,fin2

entero : numsec

inicio

ordenado ← falso

mientras no ordenado hacer

// Partir

abrir(f,l,'fd')

crear(f1,'f1d')

crear(f2,'f2d');

abrir(f1,e,'f1d')

abrir(f2,e,'f2d')

fin ← falso

si FDA(f) entonces

fin ← verdad

si_no

leer_reg(f,r)

fin_si

mientras no fin hacer

ant ← r

crece ← verdad

mientras crece y no fin hacer

si menorigual(ant,r) entonces

escribir_reg(f1,r)

ant ← r

si FDA(f) entonces

fin ← verdad

si_no

leer_reg(f,r)

fin_si

si_no

crece ← falso

fin_si

fin mientras

ant ← r

crece ← verdad

mientras crece y no fin hacer

si menorigual(ant,r) entonces

escribir_reg(f2,r)

ant ← r

si FDA(f) entonces

fin ← verdad

si_no

leer_reg(f,r)

fin_si

si_no

crece ← falso

fin_si

fin_mientras

fin_mientras

cerrar(f,f1,f2)

//Mezclar

abrir(f1,l,'f1d')

abrir(f2,l.'f2d')

crear(f,'fd')

abrir(f,e,'fd')

fin1 ← falso

420 Fundamentos de programación

fin2 ← falso

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

numsec ← 0

mientras NO fin1 y NO fin2 hacer

ant1 ← r1

ant2 ← r2

crece ← verdad

mientras NO fin1 y NO fin2 y crece hacer

si menorigual(ant1,r1) y menorigual(ant2,r2) entonces

si menorigual(r1,r2) entonces

escribir_reg(f,r1)

ant1 ← r1

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

si_no

escribir_reg(f,r2)

ant2 ← r2

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

fin_si

si_no

crece ← falso

fin_si

fin_mientras

mientras NO fin1 y menorigual(ant1,r1) hacer

escribir_reg(f,r1)

ant1 ← r1

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

fin_mientras

mientras NO fin2 y menorigual(ant2,r2) hacer

escribir_reg(f,r2)

ant2 ← r2

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

Ordenación, búsqueda y fusión externa (archivos) 421

fin_mientras

numsec ← numsec + 1

fin_mientras // del mientras no fin1 y no fin2

si NO fin1 entonces

numsec ← numsec+1

mientras NO fin1 hacer

escribir_reg(f,r1)

si FDA(f1) entonces

fin1 ← verdad

si_no

leer_reg(f1,r1)

fin_si

fin_mientras

fin_si

si no fin2 entonces

numsec ← numsec+1

mientras no fin2 hacer

escribir_reg(f,r2)

si FDA(f2) entonces

fin2 ← verdad

si_no

leer_reg(f2,r2)

fin_si

fin_mientras

fin_si

cerrar(f,f1,f2)

si numsec <= 1 entonces

ordenado ← verdad

fin_si

fin_mientras // del mientras no ordenado

borrar('f1d')

borrar('f2d')

fin_procedimiento

11.5.3. Clasificación por mezcla de secuencias equilibradas

Este método utiliza la memoria de la computadora para realizar clasificaciones internas y cuatro archivos secuenciales temporales para trabajar.

Supóngase un archivo de entrada F que se desea ordenar por orden creciente de las claves de sus elementos. Se

dispone de cuatro archivos secuenciales de trabajo, F1, F2, F3 y F4, y que se pueden colocar m elementos en memoria central en un momento dado en una tabla T de m elementos. El proceso es el siguiente:

1. Lectura de archivo de entrada por bloques de n elementos.

2. Ordenación de cada uno de estos bloques y escritura alternativa sobre F1 y F2.

3. Fusión de F1 y F2 en bloques de 2n elementos que se escriben alternativamente sobre F3 y F4.

4. Fusión de F3 y F4 y escritura alternativa en F1 y F2, de bloques con 4n elementos ordenados.

5. El proceso consiste en doblar cada vez el tamaño de los bloques y utilizando las parejas (F1, F2) y (F3, F4).

Fichero de entrada

46 66 4 12 7 5 34 32 68 8 99 16 13 14 12 10

F1 4 12 46 66 8 16 68 99

F2 [5 7 32 34] [10 12 13 14]

F3 vacio

F4 vacio

422 Fundamentos de programación

Fusión por bloques

F1 vacío

F2 vacío

F3 4 5 7 12 32 34 46 66 /F4 8 10 12 13 14 16 68 99

La mezcla o fusión final es

F1 4 5 7 8 10 12 12 13 14 16 32 34 46 66 68 99

F2 vacío

F3 vacío

F4 vacío

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

11.1. Realizar el algoritmo de partición de un archivo F en dos particiones F1 y F2, según el contenido de un campo

clave C. El contenido debe tener el valor v.

algoritmo Partición_contenido

...

inicio

abrir(f, l, 'f0') //lectura

crear (f1, 'f1')

crear (f2, 'f2')

abrir (f1, e, 'f1') //escritura

abrir (f2, e, 'f2') //escritura

mientras no fda(f) hacer

leer_reg(f, r)

si r.c = v entonces

escribir_reg(f1, r)

si_no

escribir_reg(f2, r)

fin_si

fin_mientras

cerrar( f1, f2, f)

fin

11.2. Realizar el algoritmo de partición por secuencias alternativas de longitud n.

• Entrada: Archivo F

• Salida: Archivos F1, F2

• Secuencia: longitud n (n registros en cada secuencia)

• Cada n registros se almacenan alternativamente en F1 y F2.

algoritmo Partir_alternativa

tipo

registro: reg

...

fin_registro

archivo_s de reg : arch

var

logico: sw

entero: i //contador de elementos de la secuencia

arch: f, f1, f2

reg: r

inicio

abrir(f, l, 'f0') //lectura

crear (f1, 'f1')

Ordenación, búsqueda y fusión externa (archivos) 423

crear (f2, 'f2')

abrir (f1, e, 'f1') //escritura

abrir (f2, e, 'f2') //escritura

sw ← falso

i ← 0

mientras no fda(f) hacer

leer_reg(f, r)

si NO sw entonces

escribir_reg(f1, r)

si_no

escribir_reg(f2, r)

fin_si

i ← i+1

si i= n entonces

sw ← verdadero

i ← 0 //se inicializa el contador de la secuencia

fin_si

fin_mientras

cerrar(f, f1, f2)

fin

11.3. Aplicar el algoritmo de mezcla directa al archivo F de claves.

F: 9 7 2 8 16 15 2 10

1. Primera división (partición en secuencias de longitud 1)

F1: 9 2 16 2

F2: 7 8 15 10

2. Mezcla de F1 y F2, formando pares ordenados

F: 7 9 || 2 8 || 15 16 || 2 10

3. Segunda división (partición en secuencias de longitud 2)

F1: 7 9 || 15 16

F2: 2 8 || 2 10

4. Mezcla de F1 y F2

F: 2 7 8 9 || 2 10 15 16

5. Tercera división (partición en secuencias de longitud 4)

F1: 2 7 8 9

F2: 2 10 15 16

6. Mezcla de F1 y F2 (última)

F: 2 2 7 8 9 10 15 16

11.4. Escribir el procedimiento de mezcla de dos archivos ordenados en secuencias de una determinada longitud.

procedimiento fusion (E cadena: nombre1, nombre2, nombre3; E entero: lgtud)

var

arch : f1, f2, f

//el tipo arch se supone definido en el programa principal

reg: r1, r2

// el tipo reg se supone definido en el programa principal

entero : i, j

lógico : fin1, fin2

inicio

{los nombres de los archivos en el dispositivo de almacenamiento se

424 Fundamentos de programación

pasan al procedimiento de fusión a través de las variables nombre1,

nombre2 y nombre3 }

abrir(f1,l, nombre1)

abrir(f2,l, nombre2)

crear(f, nombre3)

abrir (f, e, nombre3)

leerRegYFin(f1, r1, fin1)

{ leerRegYFin es un procedimiento, desarrollado más adelante, que

lee un registro y detecta la marca de fin de archivo}

leerRegYFin(f2, r2, fin2)

mientras no fin1 o no fin2 hacer

i ← 0

j ← 0

mientras no fin1 y no fin2 y (i<lgtud) y (j<lgtud) hacer

//lgtud es la longitud de la secuencia recibida como parámetro

si menor(r1,r2) entonces

escribir_reg(f,r1)

leerRegYFin(f1, r1, fin1)

i ← i+1

si_no

escribir_reg(f,r2)

leerRegYFin(f2, r2, fin2)

j ← j+1

fin_si

fin_mientras

mientras no fin1 y (i < lgtud) hacer

escribir_reg(f,r1)

leerRegYFin(f1, r1, fin1)

i ← i+1

fin_mientras

mientras no fin2 y (j < lgtud) hacer

escribir_reg(f,r2)

leerRegYFin(f2, r2, fin2)

j ← j+1

fin_mientras

fin_mientras // del mientras no fin1 o no fin2

cerrar(f,f1,f2)

fin_procedimiento

procedimiento leerRegYFin(E/S arch: f; E/S reg: r; E/S lógico: fin)

inicio

si fda(f) entonces

fin ← verdad

si_no

leer_reg(f, r)

fin_si

fin_procedimiento

11.5. Escribir el procedimiento de ordenación por mezcla directa de un archivo con long registros, utilizando el procedimiento fusión del ejercicio anterior.

procedimiento ordenarDirecta(E cadena: nombref, nombref1, nombref2;

E entero: long)

var

entero: lgtud

inicio

lgtud ← 1

mientras lgtud <= long hacer

partirAlternativoEnSec (nombref, nombref1, nombref2, lgtud)

fusion(nombref1, nombref2, nombref, lgtud)

lgtud ← lgtud * 2

Ordenación, búsqueda y fusión externa (archivos) 425

fin_mientras

borrar(nombref1)

borrar(nombref2)

fin_procedimiento

procedimiento partirAlternativoEnSec (E cadena: nombref, nombref1,

nombref2; E entero: lgtud)

var

lógico: sw

entero: i // contador de elementos de la secuencia

arch : f1, f2, f // tipo definido en el programa principal

reg: r // tipo definido en el programa principal

inicio

abrir(f, l, nombref) //lectura

crear (f1, nombref1)

crear (f2, nombref2)

abrir (f1, e, nombref1) //escritura

abrir (f2, e, nombref2) //escritura

sw ← falso

i ← 0

mientras no fda(f) hacer

leer_reg(f, r)

si NO sw entonces

escribir_reg(f1, r)

si_no

escribir_reg(f2, r)

fin_si

i ← i+1

si i= lgtud entonces

sw ← verdadero

i ← 0 //se inicializa el contador de la secuencia

fin_si

fin_mientras

cerrar(f, f1, f2)

fin

11.6. Escribir el procedimiento de ordenación por mezcla natural de un archivo, utilizando los procedimientos auxiliares

partir y mezclar que se suponen implementados. El procedimiento partir aprovecha las secuencias ordenadas

que pudieran existir en el archivo original y las coloca alternativamente sobre dos archivos auxiliares. El procedimiento mezclar construye a partir de dos ficheros auxiliares un nuevo fichero, mezclando las secuencias crecientes

que encuentra en los ficheros auxiliares para construir sobre el destino secuencias crecientes de longitud mayor.

procedimiento ordenarNatural(E cadena: nombref, nombref1, nombref2)

var

entero: numsec

lógico: ordenado

inicio

ordenado ← falso

mientras NO ordenado hacer

partir (nombref, nombref1, nombref2)

numsec ← 0

mezclar(nombref1, nombref2, nombref, numsec)

si numsec <=1 entonces

ordenado ← verdad

fin_si

fin_mientras

borrar(nombref1)

borrar(nombref2)

fin_procedimiento

426 Fundamentos de programación

CONCEPTOS CLAVE

• Mezcla.

• Mezcla directa.

• Mezcla natural.

• Ordenación externa.

• Partición.

RESUMEN

La ordenación externa se emplea cuando la masa de datos

a procesar es grande y no cabe en la memoria central de la

computadora. Si el archivo es directo, aunque los registros

se encuentran colocados en él de forma secuencial, servirá

cualquiera de los métodos de clasificación vistos como métodos de ordenación interna, con ligeras modificaciones

debido a las operaciones de lectura y escritura de registros

en el disco. Si el archivo es secuencial, es necesario emplear otros métodos basados en procesos de partición y

medida.

1. La partición es el proceso por el cual los registros

de un archivo se reparten en otros dos o más archivos en función de una condición.

2. La fusión o mezcla consiste en reunir en un archivo los registros de dos o más. Habitual mente los

registros de los archivos originales se encuentran

ordenados por un campo clave, y la mezcla ha de

efectuarse de tal forma que se obtenga un archivo

ordenado por dicho campo clave.

3. Los archivos están clasificados en orden ascendente o descendente cuando todos sus registros

están ordenados en sentido ascendente o descendente respecto al valor de un campo determinado,

denominado clave de ordenación. Los algoritmos

de clasificación son muy variados: (1) si el archivo a ordenar cabe en memoria central, se carga

en un vector y se realiza una clasificación interna,

transfiriendo a continuación el archivo ordenado

al soporte externo; (2) si el archivo a ordenar

no cabe en memoria central y es secuencial son

aplicables la mezcla directa y la mezcla natural;

(3) si no es secuencial pueden aplicarse métodos

similares a los vistos en la clasificación interna

con ligeras modificaciones; (4) otros métodos se

basan en procedimientos mixtos consistentes en

aprovechar al máximo la capacidad de la memoria

central.

4. La clasificación por mezcla directa consiste en

una partición sucesiva del archivo y una fusión

que produce secuencias ordenadas. La primera

partición se hace para secuencias de longitud 1

y la fusión producirá secuencias ordenadas de

longitud 2. A cada nueva partición y fusión se

duplicará la longitud de las secuencias ordenadas.

El método terminará cuando la longitud de la secuencia ordenada exceda la longitud del archivo

a ordenar.

5. La clasificación por mezcla natural consiste en

aprovechar la posible ordenación interna de las

secuencias del archivo original (F), obteniendo

con ellas particiones ordenadas de longitud variable sobre los ficheros auxiliares. A partir de

estos ficheros auxiliares escribiremos un nuevo F

mezclando los segmentos crecientes de cada uno

de ellos.

6. La búsqueda es el proceso de localizar un registro

en un archivo con un determinado valor en uno de

sus campos. Los archivos de tipo secuencial obligan a efectuar búsquedas secuenciales, mientras

que los archivos directos son estructuras de acceso

aleatorio y permiten otros tipos de búsquedas.

7. La búsqueda binaria podría aplicarse a archivos

directos con los registros colocados uno a continuación de otro y ordenados por el campo por el

que se desea efectuar la búsqueda.

Ordenación, búsqueda y fusión externa (archivos) 427

EJERCICIOS

11.1. Se desea intercalar los registros del archivo P con los

registros del archivo Q y grabarlos en otro archivo R.

NOTA: Los archivos P y Q están clasificados en orden ascendente por una determinada clave y se desea

que el archivo R quede también ordenado en modo

ascendente.

11.2. Los archivos M, N y P contienen todas las operaciones

de ventas de una empresa en los años 1985, 1986 y

1987 respectivamente. Se desea un algoritmo que

intercale los registros de los tres archivos en un solo

archivo Z, teniendo en cuenta que los tres archivos

están clasificados en orden ascendente por el campo

clave ventas.

11.3. Se dispone de dos archivos secuenciales F1 y F2 que

contienen cada uno de ellos los mismos campos. Los

dos archivos están ordenados de modo ascendente

por el campo clave (alfanumérico) y existen registros

comunes a ambos archivos. Se desea diseñar un programa que obtenga: a) un archivo C a partir de F1 y

F2, que contenga todos los registros comunes, pero

sólo una vez; b) un archivo que contenga todos los

registros que no son comunes a F1 y F2.

11.4. Se desea intercalar los registros del archivo A con los

registros del archivo B y grabarlos en un tercer archivo C. Los archivos A y B están clasificados en

orden ascendente por su campo clave. Y se desea

también que el archivo C quede clasificado en orden

ascendente.

11.5. El archivo A contiene los números de socios del Club

Deportivo Esmeralda y el archivo B los códigos de

los socios del Club Deportivo Diamante. Se desea

crear un archivo C que contenga los números de los

socios que pertenecen a ambos clubes. Asimismo, se

desea saber cuántos registros se han leído y cuántos

se han grabado.

11.6. Los archivos F1, F2 y F3 contienen todas las operaciones de ventas de una compañía informática en los

años 1985, 1986 y 1987 respectivamente. Se desea un

programa que intercale todos los registros de los tres

archivos en un solo archivo F, suponiendo que todo

registro posee un campo clave y que F1, F2 y F3 están

clasificados en orden ascendente de ese campo clave.

11.7. Se desea actualizar un archivo maestro de la nómina

de la compañía Aguas del Pacífico con un archivo

MODIFICACIONES que contiene todas las incidencias

de empleados (altas, bajas, modificaciones). Ambos

archivos están clasificados en orden ascendente del

código de empleado (campo clave). El nuevo archivo

maestro actualizado debe conservar la clasificación

ascendente por código de empleado y sólo debe existir un registro por empleado.

11.8. Se tiene un archivo maestro de inventarios con los

siguientes campos:

CODIGO DE ARTICULO DESCRIPCION

EXISTENCIAS

Se desea actualizar el archivo maestro con los movimientos habidos durante el mes (altas/bajas). Para

ello se incluyen los movimientos en un archivo OPERACIONES que contiene los siguientes campos:

CODIGO DE ARTICULO CANTIDAD

OPERACION (1-Alta, 2-Baja)

Los dos archivos están clasificados por el mismo

campo clave.

CAPÍTULO 12

Estructuras dinámicas

lineales de datos

(pilas, colas y listas enlazadas)

12.1. Introducción a las estructuras de datos

12.2. Listas

12.3. Listas enlazadas

12.4. Procesamiento de listas enlazadas

12.5. Listas circulares

12.6. Listas doblemente enlazadas

12.7. Pilas

12.8. Colas

12.9. Doble cola

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

CONCEPTOS CLAVE

RESUMEN

EJERCICIOS

Los datos estudiados hasta ahora se denominan estáticos. Ello es debido a que las variables son direcciones

simbólicas de posiciones de memoria; esta relación

entre nombres de variables y posiciones de memoria

es una relación estática que se establece por la declaración de las variables de una unidad de programa y

que se establece durante la ejecución de esa unidad.

Aunque el contenido de una posición de memoria

asociada con una variable puede cambiar durante la

ejecución, es decir, el valor de la variable puede cambiar, las variables por sí mismas no se pueden crear ni

destruir durante la ejecución. En consecuencia, las variables consideradas hasta este punto se denominan

variables estáticas.

En algunas ocasiones, sin embargo, no se conoce

por adelantado cuánta memoria se requerirá para un

programa. En esos casos es conveniente disponer de

un método para adquirir posiciones adicionales de

memoria a medida que se necesiten durante la ejecución del programa y liberarlas cuando no se necesitan.

Las variables que se crean y están disponibles durante

la ejecución de un programa se llaman variables dinámicas. Estas variables se representan con un tipo de

datos conocido como puntero. Las variables dinámicas

se utilizan para crear estructuras dinámicas de datos

que se pueden ampliar y comprimir a medida que se

requieran durante la ejecución del programa. Una estructura de datos dinámica es una colección de elementos denominados nodos de la estructura —normalmente de tipo registro— que son enlazados juntos.

Las estructuras dinámicas de datos se clasifican en

lineales y no lineales. El estudio de las estructuras lineales, listas, pilas y colas, es el objetivo de este capítulo.

INTRODUCCIÓN

430 Fundamentos de programación

12.1. INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS

En capítulos anteriores se ha introducido a las estructuras de datos, definiendo tipos y estructuras de datos primitivos,

tales como enteros, real y carácter, utilizados para construir tipos más complicados como arrays y registros, denominados estructuras de datos compuestos. Tienen una estructura porque sus datos están relacionados entre sí. Las

estructuras compuestas, tales como arrays y registros, están soportadas en la mayoría de los lenguajes de programación, debido a que son necesarias en casi todas las aplicaciones.

La potencia y flexibilidad de un lenguaje está directamente relacionada con las estructuras de datos que posee.

La programación de algoritmos complicados puede resultar muy difícil en un lenguaje con estructuras de datos limitados, caso de FORTRAN y COBOL. En ese caso es conveniente pensar en la implementación con lenguajes que

soporten punteros como C y C++ o bien que no soporten pero tengan recolección de basura como Java o C#, o bien

recurrir, al menos en el período de formación, al clásico Pascal.

Cuando una aplicación particular requiere una estructura de datos no soportada por el lenguaje, se hace necesaria

una labor de programación para representarla. Se dice que necesitamos implementar la estructura de datos. Esto naturalmente significa más trabajo para el programador. Si la programación no se hace bien, se puede malgastar tiempo de programación y —naturalmente— de computadora. Por ejemplo, supongamos que tenemos un lenguaje como

Pascal que permite arrays de una dimensión de números enteros y reales, pero no arrays multidimensionales. Para

implementar una tabla con cinco filas y diez columnas podemos utilizar

type

array[0..10] of real: FILA;

var

FILA: FILA1, FILA2, FILA3, FILA4, FILA5;

La llamada al elemento de la tercera fila y sexta columna se realizará con la instrucción

FILA3 [6]

Un método muy eficaz es diseñar procedimientos y funciones que ejecuten las operaciones realizadas por las

estructuras de datos. Sin embargo, con las estructuras vistas hasta ahora arrays y registros tienen dos inconvenientes:

1) la reorganización de una lista, si ésta implica movimiento de muchos elementos de datos, puede ser muy costosa,

y 2) son estructuras de datos estáticas.

Una estructura de datos se dice que es estática cuando el tamaño ocupado en memoria es fijo, es decir, siempre

ocupa la misma cantidad de espacio en memoria. Por consiguiente, si se representa una lista como vector, se debe

anticipar (declarar o dimensionar) la longitud de esa lista cuando se escribe un programa; es imposible ampliar el

espacio de memoria disponible (algunos lenguajes permiten dimensionar dinámicamente el tamaño de un array durante la ejecución del programa, como es el caso de Visual BASIC). En consecuencia, puede resultar difícil representar diferentes estructuras de datos.

Los arrays unidimensionales son estructuras estáticas lineales ordenadas secuencialmente. Las estructuras se convierten en dinámicas cuando los elementos pueden ser insertados o suprimidos directamente sin necesidad de algoritmos complejos. Se distinguen las estructuras dinámicas de las estáticas por los modos en que se realizan las inserciones y borrados de elementos.

12.1.1. Estructuras dinámicas de datos

Las estructuras dinámicas de datos son estructuras que «crecen a medida que se ejecuta un programa». Una estructura dinámica de datos es una colección de elementos —llamados nodos— que son normalmente registros. Al contrario que un array, que contiene espacio para almacenar un número fijo de elementos, una estructura dinámica de

datos se amplía y contrae durante la ejecución del programa, basada en los registros de almacenamiento de datos del

programa.

Las estructuras dinámicas de datos se pueden dividir en dos grandes grupos:

lineales { pilas

colas

listas enlazadas

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 431

no lineales { árboles

grafos

Las estructuras dinámicas de datos se utilizan para almacenamiento de datos del mundo real que están cambiando constantemente. Un ejemplo típico ya lo hemos visto como estructura estática de datos: la lista de pasajeros de una línea aérea. Si esta lista se mantuviera en orden alfabético en un array, sería necesario hacer espacio

para insertar un nuevo pasajero por orden alfabético. Esto requiere utilizar un bucle para copiar los datos del registro de cada pasajero en el siguiente elemento del array. Si en su lugar se utilizara una estructura dinámica de

datos, los nuevos datos del pasajero se pueden insertar simplemente entre dos registros existentes sin un mínimo

esfuerzo.

Las estructuras dinámicas de datos son extremadamente flexibles. Como se ha descrito anteriormente, es relativamente fácil añadir nueva información creando un nuevo nodo e insertándolo entre nodos existentes. Se verá que es

también relativamente fácil modificar estructuras dinámicas de datos, eliminando o borrando un nodo existente.

En este capítulo examinaremos las tres estructuras dinámicas lineales de datos: listas, colas y pilas, dejando para

el próximo capítulo las estructuras no lineales de datos: árboles y grafos.

Una estructura estática de datos es aquella cuya estructura se especifica en el momento en que se escribe el

programa y no puede ser modificada por el programa. Los valores de sus diferentes elementos pueden variar,

pero no su estructura, ya que ésta es fija.

Una estructura dinámica de datos puede modificar su estructura mediante el programa. Puede ampliar o limitar

su tamaño mientras se ejecuta el programa.

12.2. LISTAS

Una lista lineal es un conjunto de elementos de un tipo dado que pueden variar en número y donde cada elemento

tiene un único predecesor y un único sucesor o siguiente, excepto el primero y último de la lista. Esta es una definición muy general que incluye los ficheros y vectores.

Los elementos de una lista lineal se almacenan normalmente contiguos —un elemento detrás de otro— en posiciones consecutivas de la memoria. Las sucesivas entradas en una guía o directorio telefónico, por ejemplo, están en

líneas sucesivas, excepto en las partes superior e inferior de cada columna. Una lista lineal se almacena en la memoria principal de una computadora en posiciones sucesivas de memoria; cuando se almacenan en cinta magnética,

los elementos sucesivos se presentan en sucesión en la cinta. Esta asignación de memoria se denomina almacenamiento secuencial. Posteriormente se verá que existe otro tipo de almacenamiento denominado encadenado o enlazado.

Las líneas así definidas se denominan contiguas. Las operaciones que se pueden realizar con listas lineales contiguas son:

1. Insertar, eliminar o localizar un elemento.

2. Determinar el tamaño —número de elementos— de la lista.

3. Recorrer la lista para localizar un determinado elemento.

4. Clasificar los elementos de la lista en orden ascendente o descendente.

5. Unir dos o más listas en una sola.

6. Dividir una lista en varias sublistas.

7. Copiar la lista.

8. Borrar la lista.

Una lista lineal contigua se almacena en la memoria de la computadora en posiciones sucesivas o adyacentes y

se procesa como un array unidimensional. En este caso, el acceso a cualquier elemento de la lista y la adición de

nuevos elementos es fácil; sin embargo, la inserción o borrado requiere un desplazamiento de lugar de los elementos

que le siguen y, en consecuencia, el diseño de un algoritmo específico.

Para permitir operaciones con listas como arrays se deben dimensionar éstos con tamaño suficiente para que

contengan todos los posibles elementos de la lista.

432 Fundamentos de programación

EJEMPLO 12.1

Se desea leer el elemento j-ésimo de una lista P.

El algoritmo requiere conocer el número de elementos de la lista (su longitud, L). Los pasos a dar son:

1. conocer longitud de la lista L.

2. si L = 0 visualizar «error lista vacía».

si_no comprobar si el elemento j-ésimo está dentro del rango permitido de elementos 1 <= j <= L; en este

caso, asignar el valor del elemento P(j) a una variable B; si el elemento j-ésimo no está dentro del rango,

visualizar un mensaje de error «elemento solicitado no existe en la lista».

3. fin.

El pseudocódigo correspondiente sería:

procedimiento acceso(E lista: P; S elementolista: B; E entero: L, J)

inicio

si L = 0 entonces

escribir('Lista vacia')

si_no

si (j >= 1) y (j <= L) entonces

B ← P[j]

si_no

escribir('ERROR: elemento no existente')

fin_si

fin_si

fin

EJEMPLO 12.2

Borrar un elemento j de la lista P.

Variables

L longitud de la lista

J posición del elemento a borrar

I subíndice del array P

P lista

Las operaciones necesarias son:

1. Comprobar si la lista es vacía.

2. Comprobar si el valor de J está en el rango I de la lista 1 <= J <= L.

3. En caso de J correcto, mover los elementos J+1, J+2, ..., a las posiciones J, J+1, ..., respectivamente,

con lo que se habrá borrado el antiguo elemento J.

4. Decrementar en uno el valor de la variable L, ya que la lista contendrá ahora L – 1 elementos.

El algoritmo correspondiente será:

inicio

si L = 0 entonces

escribir('lista vacia')

si_no

leer(J)

si (J >= 1) y (J <= L) entonces

desde I ← J hasta L-1 hacer

P[I] ← P[I+1]

fin_desde

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 433

L ← L-1

si_no

escribir('Elemento no existe')

fin_si

fin_si

fin

Una lista contigua es aquella cuyos elementos son adyacentes en la memoria o soporte direccionable. Tiene unos

límites izquierdo y derecho o inferior/superior que no pueden ser rebajados cuando se le añade un elemento.

La inserción o eliminación de un elemento, excepto en la cabecera o final de la lista, necesita una traslación

de una parte de los elementos de la misma: la que precede o sigue a la posición del elemento modificado.

Las operaciones directas de añadir y eliminar se efectúan únicamente en los extremos de la lista. Esta limitación es una de las razones por las que esta estructura es poco utilizada.

Las listas enlazadas o de almacenamiento enlazado o encadenado son mucho más flexibles y potentes, y su uso

es mucho más amplio que las listas contiguas.

12.3. LISTAS ENLAZADAS1

Los inconvenientes de las listas contiguas se eliminan con las listas enlazadas. Se pueden almacenar los elementos

de una lista lineal en posiciones de memoria que no sean contiguas o adyacentes.

Una lista enlazada o encadenada es un conjunto de elementos en los que cada elemento contiene la posición

—o dirección— del siguiente elemento de la lista. Cada elemento de la lista enlazada debe tener al menos dos campos: un campo que tiene el valor del elemento y un campo (enlace, link) que contiene la posición del siguiente elemento, es decir, su conexión, enlace o encadenamiento. Los elementos de una lista son enlazados por medio de los

campos enlaces.

Las listas enlazadas tienen una terminología propia que se suele utilizar normalmente. Primero, los valores se

almacenan en un nodo (Figura 12.1).

Dato

(valor elemento)

Enlace

Figura 12.1. Nodo con dos campos.

Una lista enlazada se muestra en la Figura 12.2.

5 4 1 7 18 19 9 7 45 …

(a)

(b)

LISTA

5 4 1 7 18 19 9 7 45

Figura 12.2. (a) array representado por una lista; (b) lista enlazada representada por una lista de enteros.

Los componentes de un nodo se llaman campos. Un nodo tiene al menos un campo dato o valor y un enlace (indicador o puntero) con el siguiente nodo. El campo enlace apunta (proporciona la dirección o referencia de) al siguiente nodo de la lista. El último nodo de la lista enlazada, por convenio, se suele representar por un enlace con la palabra

reservada nil (nulo), una barra inclinada (/) y, en ocasiones, el símbolo eléctrico de tierra o masa (Figura 12.3).

1

Las listas enlazadas se conocen también en Latinoamérica con el término «ligadas» y «encadenadas». El término en inglés es linked list.

434 Fundamentos de programación

4 4 nil 4

Figura 12.3. Representación del último nodo de una lista.

La implementación de una lista enlazada depende del lenguaje. C, C++, Pascal, PL/I, Ada y Modula-2 utilizan

simplemente como enlace una variable puntero, o puntero (apuntador). Java no dispone de punteros, por consiguiente, resuelve el problema de forma diferente y almacena en el enlace la referencia al siguiente objeto nodo. Los

lenguajes como FORTRAN y COBOL no disponen de este tipo de datos y se debe simular con una variable entera

que actúa como indicador o cursor. En nuestro libro utilizaremos a partir de ahora el término puntero (apuntador)

para describir el enlace entre dos elementos o nodos de una lista enlazada.

Un puntero (apuntador) es una variable cuyo valor es la dirección o posición de otra variable.

En las listas enlazadas no es necesario que los elementos de la lista sean almacenados en posiciones físicas adyacentes, ya que el puntero indica dónde se encuentra el siguiente elemento de la lista, tal como se indica en la Figura 12.4.

NULO

INFO SIG

INFO SIG

INFO SIG

INFO SIG

PRIMERO

Figura 12.4. Elementos no adyacentes de una lista enlazada.

Por consiguiente, la inserción y borrado no exigen desplazamiento como en el caso de las listas contiguas.

Para eliminar el 45.º elemento ('INÉS') de una lista lineal con 2.500 elementos [Figura 12.5 (a)] sólo es necesario cambiar el puntero en el elemento anterior, 44.º, y que apunte ahora al elemento 46.º [Figura 12.5 (b)]. Para

insertar un nuevo elemento ('HIGINIO') después del 43.º ('GONZALO') elemento, es necesario cambiar el puntero

del elemento 43.º y hacer que el nuevo elemento apunte al elemento 44.º [Figura 12.5 (c)].

GONZALO HORACIO INÉS IVÁN JUAN ZAYA NULO

(a)

GONZALO HORACIO INÉS IVÁN JUAN ZAYA NULO

(b)

(c)

HIGINI O

GONZALO HORACIO IVÁN JUAN ZAYA NULO

Figura 12.5. Inserción y borrado de elementos.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 435

Una lista enlazada sin ningún elemento se llama lista vacía. Su puntero inicial o de cabecera tiene el valor nulo

(nil).

Una lista enlazada se define por:

• El tipo de sus elementos: campo de información (datos) y campo enlace (puntero o apuntador).

• Un puntero de cabecera que permite acceder al primer elemento de la lista.

• Un medio para detectar el último elemento de la lista: puntero nulo (nil).

EJEMPLO 12.3

El director de un hotel desea registrar el nombre de cada cliente a medida de su llegada al hotel, junto con el número de habitación que ocupa —el antiguo libro de entradas—. También desea disponer en cualquier momento de

una lista de sus clientes por orden alfabético.

Ya que no es posible registrar los clientes alfabética y cronológicamente en la misma lista, se necesita o bien

listas alfabéticas independientes o bien añadir punteros a la lista existente, con lo que sólo se utilizará una única lista. El método manual en el libro requería muchos cruces y reescrituras; sin embargo, una computadora mediante un

algoritmo adecuado lo realizará fácilmente.

Por cada nodo de la lista el campo de información o datos tiene dos partes: nombre del cliente y número de habitación. Si x es un puntero a uno de estos nodos, l[x].nombre y l[x].habitación representarán las dos partes del

campo información.

El listado alfabético se consigue siguiendo el orden de los punteros de la lista (campo puntero). Se utiliza una

variable CABECERA(S) para apuntar al primer cliente.

CABECERA ← 3

Así, CABECERA(S) es 3, ya que el primer cliente, Antolín, ocupa el lugar 3. A su vez, el puntero asociado al

nodo ocupado por Antolín contiene el valor 10, que es el segundo nombre de los clientes en orden alfabético y éste

tiene como campo puntero el valor 7, y así sucesivamente. El campo puntero del último cliente, Tomás, contiene el

puntero nulo indicado por un 0 o bien una Z.

Registro Nombre Habitación Puntero

S(=3) 1 Tomás 324 z (final)

2 Cazorla 28 8

3 Antolín 95 10

4 Pérez 462 6

5 López 260 12

6 Sánchez 220 1

7 Bautista 115 2

8 García 105 9

9 Jiménez 173 5

10 Apolinar 341 7

11 Martín 205 4

12 Luzárraga 420 11

.

.

.

.

.

.

.

.

.

.

.

.

Figura 12.6. Lista enlazada de clientes de un hotel.

436 Fundamentos de programación

12.4. PROCESAMIENTO DE LISTAS ENLAZADAS

Para procesar una lista enlazada se necesitan las siguientes informaciones:

• Primer nodo (cabecera de la lista).

• El tipo de sus elementos.

Las operaciones que normalmente se ejecutan con listas incluyen:

1. Recuperar información de un nodo específico (acceso a un elemento).

2. Encontrar el nodo que contiene una información específica (localizar la posición de un elemento dado).

3. Insertar un nuevo nodo en un lugar específico de la lista.

4. Insertar un nuevo nodo en relación a una información particular.

5. Borrar (eliminar) un nodo existente que contiene información específica.

12.4.1. Implementación de listas enlazadas con punteros

Como ya hemos visto, la representación gráfica de un puntero consiste en una flecha que sale del puntero y llega a

la variable dinámica apufintada.

Para declarar una variable de tipo puntero:

tipo

puntero_a <tipo_dato>: punt

var

punt : p, q

El <tipo_dato> podrá ser simple o estructurado.

Operaciones con punteros:

Inicialización

p ← nulo A nulo para indicar que no apunta a ninguna variable.

Comparación

p = q Con los operadores = o <>.

p

q

p→ q→

Asignación

p ← q Implica hacer que el puntero p apunte a donde apunta q.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 437

Creación de variables dinámicas

Reservar(p) Reservar espacio en memoria para la variable dinámica.

Eliminación de variables dinámicas

Liberar(p) Liberar el espacio en memoria ocupado por la variable dinámica.

Variables dinámicas

Variable simple o estructura de datos sin nombre y creada en tiempo de ejecución.

p p →

Para acceder a una variable dinámica apuntada, como no tiene nombre se escribe p →

Las variables p → podrán intervenir en toda operación o expresión de las permitidas para una variable estática

de su mismo tipo.

Nodo

Las estructuras dinámicas de datos están formadas por nodos.

Un nodo es una variable dinámica constituida por al menos dos campos:

• el campo dato o valor (elemento);

• el campo enlace, en este caso de tipo puntero (sig).

elemento sig

tipo

registro: nodo

//elemento es el campo que contiene la información

<tipo_elemento>: elemento

//punt apunta al siguiente elemento de la estructura

punt : sig

{según la estructura de que se trate podrá haber uno o varios

campos de tipo punt}

... : ...

fin_registro

Creación de la lista

La creación de la lista conlleva la inicialización a nulo del puntero (inic), que apunta al primer elemento de la lista.

tipo

puntero_a nodo: punt

registro: tipo_elemento

... : ...

fin_registro

registro: nodo

438 Fundamentos de programación

tipo_elemento : elemento

punt : sig

fin_registro

var punt : inic, posic, anterior

tipo_elemento : elemento

logico : encontrado

inicio

inicializar(inic)

...

fin

procedimiento inicializar(S punt: inic)

inicio

inic ← nulo

fin_procedimiento

inic

nulo

Inserción de un elemento

La inserción tiene dos casos particulares:

• Insertar el nuevo nodo en el frente, principio de la lista.

• Insertar el nuevo nodo en cualquier otro lugar de la lista.

El procedimiento insertar inserta un nuevo elemento a continuación de anterior, si anterior fuera nulo

significa que ha de insertarse al comienzo de la lista.

1.º

anterior →

elemento

xxxx

zzzz anterior

nulo

inic

insertar(inic, anterior, elemento)

2.º

3.º

auxi→

elemento sig

yyyy

auxi

auxi

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 439

anterior

xxxx

zzzz anterior

nulo

inic

4.º

5.º

yyyy

elemento sig

auxi

auxi

→

1.º Situación de partida.

2.º reservar(auxi).

3.º Introducir la nueva información en auxi→.elemento.

4.º Hacer que auxi→ sig apunte a donde lo hacía anterior→.sig.

5.º Conseguir que anterior→.sig apunte a donde lo hace auxi.

procedimiento insertar( E/S punt: inic,anterior;

E tipo_elemento: elemento)

var punt: auxi

inicio

reservar(auxi)

auxi→.elemento ← elemento

si anterior = nulo entonces

auxi →.sig ← inic

inic ← auxi

si_no

auxi→.sig ← anterior→.sig

anterior→.sig ← auxi

fin_si

anterior ← auxi // Opcional

fin_procedimiento

Eliminación de un elemento de una lista enlazada

Antes de proceder a la eliminación de un elemento de la lista, deberemos comprobar que no está vacía. Para lo que

podremos recurrir a la función vacia.

lógico función vacia(E punt: inic)

inicio

devolver(inic = nulo)

fin_función

Al suprimir un elemento de una lista consideraremos dos casos particulares:

• El elemento a suprimir está al principio de la lista.

• El elemento se encuentra en cualquier otro lugar de la lista.

1.º Situación de partida.

2.º anterior →.sig apunta a donde posic →.sig.

3.º liberar(posic).

440 Fundamentos de programación

procedimiento suprimir(E/S punt: inic, anterior, posic)

inicio

si anterior = nulo entonces

inic ← posic→.sig

si_no

anterior→.sig ← posic→.sig

fin_si

liberar(posic)

anterior ← nulo // Opcional

posic ← inic // Opcional

fin_procedimiento

anterior

elemento

xxxx

zzzz

anterior

nulo

inic

yyyy

elemento sig posic

posic

→

→

1.º

Suprimir(inic, anterior, posic)

anterior →

elemento

xxxx

zzzz

anterior

nul

3.º 2.º o

inic

yyyy sig

posic

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 441

Java y C# permiten la creación de listas enlazadas vinculando objetos nodo sin el empleo de punteros, en el enlace se almacena la referencia al siguiente nodo de la lista. En estos lenguajes, aunque la implementación de una

lista enlazada resulta similar, hay que tener en cuenta que al crear un objeto nodo se reserva espacio en memoria para

él y que este espacio se libera automáticamente, a través de un proceso denominado recolección automática de basura, cuando dicho objeto (nodo) deja de estar referenciado.

Recorrido de una lista enlazada

Para recorrer la lista utilizaremos una variable de tipo puntero auxiliar.

procedimiento recorrer(E punt:inic)

var punt: posic

inicio

posic ← inic

mientras posic <> nulo hacer

proc_escribir(posic→.elemento)

posic ← posic→.sig

fin_mientras

fin_procedimiento

EJEMPLO 12.4

Cálculo del número de elementos de una lista enlazada.

procedimiento contar(E punt: primero; S entero: n)

var punt: p

inicio

n ← 0 //contador de elementos

p ← primero

mientras p <> nulo hacer

n ← n + 1

p ← p →.sig

fin_mientras

fin_procedimiento

Acceso a un elemento de una lista enlazada

La búsqueda de una información en una lista simplemente enlazada sólo puede hacerse mediante un proceso secuencial o recorrido de la lista elemento a elemento, hasta encontrar la información buscada o detectar el final de la lista.

procedimiento consultar( E punt: inic; S punt: posic,anterior;

E tipo_elemento: elemento; S lógico: encontrado)

inicio

encontrado ← falso

anterior ← nulo

posic ← inic

mientras no igual(posic→.elemento,elemento) y (posic <> nulo) hacer

{ igual es una función que compara los elementos que le pasamos como

parámetros, recurrimos a ella porque, si se tratara de registros,

compararíamos únicamente la información almacenada en un

determinado campo }

si

fin_mientras

si igual(posic→.elemento, elemento) entonces

encontrado ← verdad

442 Fundamentos de programación

si_no

encontrado ← falso

fin_si

fin_procedimiento

EJEMPLO 12.5

Encontrar el nodo de una lista que contiene la información de valor t, suponiendo que la lista almacena datos de

tipo entero.

procedimiento encontrar(E punt: primero E entero: t)

var punt : p

entero: n

inicio

n ← 0

p ← primero

mientras (p→.info <> t) y (p <> nulo) hacer

n ← n + 1

p ← p →.sig

fin_mientras

si p→.info = t entonces

escribir('Se encuentra en el nodo ',n,' de la lista')

si_no

escribir('No encontrado')

fin_si

fin_procedimiento

Considere que la información se encuentra almacenada en la lista de forma ordenada, orden creciente, y mejore

la eficacia del algoritmo anterior.

procedimiento encontrar(E punt: primero E entero: t)

var punt : p

entero: n

inicio

n ← 0

p ← primero

mientras (p →.info < t) y (p <> nulo) hacer

n ← n + 1

p ← p →.sig

fin_mientras

si p →.info = t entonces

escribir('Se encuentra en el nodo ',n,' de la lista')

si_no

escribir('No encontrado')

fin_si

fin_procedimiento

12.4.2. Implementación de listas enlazadas con arrays (arreglos)

Las listas enlazadas deberán implementarse de forma dinámica, pero si el lenguaje no lo permite, lo realizaremos a

través de arrays (o arreglos), con lo cual impondremos limitaciones en cuanto al número de elementos que podrá

contener la lista y estableceremos una ocupación en memoria constante.

Los nodos podrán almacenarse en arrays paralelos o arrays de registros.

Cuando se empleen arrays de registros, el valor (dato o información) del nodo se almacenará en un campo y el

enlace con el siguiente elemento se almacenará en otro.

Otra posible implementación, como ya se ha dicho antes, es con dos arrays: uno para los datos y otro para el enlace.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 443

Un valor de puntero 0, o bien Z, indica el final de la lista.

ELEMENTO SIG ELEMENTO SIG

XXXXXXXXXXXXX 1 2 1 XXXXXXXXXXXXX 2

XXXXXXXXXXXXX 2 4 2 XXXXXXXXXXXXX 4

3 3

XXXXXXXXXXXXX 4 6 4 XXXXXXXXXXXXX 6

5 5

XXXXXXXXXXXXX 6 0 6 XXXXXXXXXXXXX 0

Para definir la lista se debe especificar la variable que apunta al primer nodo (cabecera), que en nuestro caso

denominaremos inic.

inic ← 1

Para insertar un nuevo elemento, que siga a m[1] y sea seguido por m[2], lo único que se hará es modificar los

punteros.

M SIG

1 XXXXXXXXXXXXX 3

2 XXXXXXXXXXXXX 4

3 XXXXXXXXXXXXX 2

4 XXXXXXXXXXXXX 6

5

6 XXXXXXXXXXXXX 0

Como el nuevo elemento se coloca en la primera posición libre deberemos tener un puntero vacío que apunte a

dicha primera posición libre.

Es decir, utilizaremos el array para almacenar dos listas, la lista de elementos y la lista de vacíos.

Es, pues, necesario, al comenzar a trabajar, crear la lista de vacíos de la forma que a continuación se expone:

• vacio apunta al primer registro libre.

• En el campo sig de cada registro se almacena información sobre el siguiente registro disponible.

• Cuando lleguemos al último registro libre, su campo sig recibirá el valor 0, para indicar que ya no quedan

más registros disponibles.

ELEMENTO SIG

1 2

2 3

vacio → 1 3 4

inic → 0 4 5

5 6

6 0

444 Fundamentos de programación

Insertar el primer elemento

1 XXXXXXXXXXXXX 0

2 3

vacio → 2 3 4

inic → 1 4 5

5 6

6 0

Al implementar una lista a través de arrays necesitaremos los procedimientos:

inicializar( ) iniciar( ) consultar( ) insertar( ) suprimir( )

reservar( ) liberar( )

y las funciones

vacia( ) llena( )

El procedimiento reservar( ) nos proporcionará la primera posición vacía para almacenar un nuevo elemento

y la eliminará de la lista de vacíos, pasando el puntero de vacíos (vacio) a la posición siguiente, vacio toma el

valor del siguiente vacio de la lista.

Liberar( ) inserta un nuevo elemento en la lista de vacíos. Se podrían adoptar otras soluciones, pero nuestro

procedimiento liberar insertará el nuevo elemento en la lista de vacíos por delante, sobrescribiendo el campo

m[posic].sig para que apunte al que antes era el primer vacio. El puntero de inicio de los vacíos (vacio) lo

cambiará al nuevo elemento.

Creación de la lista

Consideraremos el array como si fuera la memoria del ordenador y guardaremos en él dos listas: la lista de elementos y la de vacíos.

El primer elemento de la lista de elementos está apuntado por inic y, por vacio, el primero de la lista de vacíos:

const

max = <expresión>

tipo

registro: tipo_elemento

... : ...

... : ...

fin_registro

registro: tipo_nodo

tipo_elemento : elemento

entero : sig

{ actúa como puntero, almacenando la posición donde se

encuentra el siguiente elemento de una lista }

fin_registro

array[1..max] de tipo_nodo: arr

var

entero : inic,

posic,

anterior,

vacio

arr : m

// m representa la memoria de nuestra computadora

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 445

tipo_elemento : elemento

logico : encontrado

inicio

iniciar(m, vacio)

inicializar(inic)

...

fin

Al comenzar:

procedimiento inicializar(S entero: inic) //lista de elementos

inicio

inic ← 0

fin_procedimiento

elemento sig

vacio ← 1 indica que el primer registro libre es m[1] 1 2

2 3

3 4

4 5

inic ← 0 inic señala que no hay elementos en la lista 5 6

6 0

procedimiento iniciar(S arr: m; S entero: vacio) //lista de vacíos

var

entero: i

inicio

vacio ← 1

desde i ← 1 hasta max-1 hacer

m[i].sig ← i+1

fin_desde

m[max].sig ← 0

//Como ya no hay más posiciones libres a las que apuntar, recibe un 0

fin_procedimiento

Al trabajar de esta manera conseguiremos que la inserción o borrado de un determinado elemento, n-ésimo, de

la lista no requiera el desplazamiento de otros.

Inserción de un elemento

Al actualizar una lista se pueden presentar dos casos particulares:

• Desbordamiento (overflow).

• Subdesbordamiento o desbordamiento negativo (underflow).

El desbordamiento se produce cuando la lista está llena y la lista de espacio disponible está vacía.

El subdesbordamiento se produce cuando se tiene una lista vacía y se desea borrar un elemento de la misma.

Luego, para poder insertar un nuevo elemento en una lista enlazada, es necesario comprobar que se dispone de

espacio libre para ello. Al insertar un nuevo elemento en la lista deberemos recurrir al procedimiento reservar(...)

que nos proporcionará, a través de auxi, la primera posición vacía para almacenar en ella el nuevo elemento, eliminando dicha posición de la lista de vacíos.

446 Fundamentos de programación

Por ejemplo, al insertar el primer elemento:

elemento Sig

1 XXXXXXXXXXXXX 2 0

2 3 0

auxi ← 1 3 4

vacio ← 2 4 5

5 6

6 0

• vacio señala que la primera posición libre es la 1 auxi ← 1

• El campo sig del registro m[vacio] proporciona la siguiente posición vacía y reservar hará que vacio

apunte a esta nueva posición vacio ← 2

Al insertar un segundo elemento:

• como vacio tiene el valor 2 auxi ← 2

• vacio ← m[2].sig, es decir vacio ← 3

elemento Sig

1 XXXXXXXXXXXXX 2 0

2 XXXXXXXXXXXXX 3

auxi ← 2 3 4

vacio ← 3 4 5

5 6

6 0

procedimiento reservar(S entero: auxi; E arr: m; E/S entero: vacio)

inicio

si vacio = 0 entonces

// Memoria agotada

auxi ← 0

si_no

auxi ← vacio

vacio ← m[vacio].sig

fin_si

fin_procedimiento

El procedimiento insertar colocará un nuevo elemento a continuación de anterior, si anterior fuera 0 significa que

ha de insertarse al comienzo de la lista.

procedimiento insertar( E/S entero: inic, anterior;

E tipo_elemento: elemento;

E/S arr: m ; E/S entero: vacio)

var

entero: auxi

inicio

reservar(auxi,m,vacio)

si auxi = 0 entonces OVERFLOW

m[auxi].elemento ← elemento

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 447

si anterior = 0 entonces

m[auxi].sig ← inic

inic ← auxi

si_no

m[auxi].sig ← m[anterior].sig

m[anterior].sig ← auxi

fin_si

anterior ← auxi // Opcional

{ Prepara anterior para que, si no especificamos otra cosa, la

siguiente inserción se realice a continuación de la actual}

fin_procedimiento

Consideremos la siguiente situación y analicemos el comportamiento que en ella tendrían los procedimientos

reservar e insertar: Se desea insertar un nuevo elemento en la lista a continuación del primero y la situación

actual, tras sucesivas inserciones y eliminaciones, es como se muestra a continuación:

1 XXXXXXXXXXXXX 2

2 XXXXXXXXXXXXX 4

vacio ← 3 3 5

inic ← 1 4 XXXXXXXXXXXXX 6

5 0

6 XXXXXXXXXXXXX 0

El nuevo elemento se colocará en el array en la primera posición libre y lo único que se hará es modificar los

punteros.

reservar(...) proporciona la primera posición libre

1 XXXXXXXXXXXXX 3

2 XXXXXXXXXXXXX 4

auxi ← 3 3 nuevo_elemento 2

4 XXXXXXXXXXXXX 6

vacio ← 5 5 0

6 XXXXXXXXXXXXX 0

m[3].elemento ← nuevo_elemento

como queremos insertar el nuevo elemento a continuación del primero de la lista, su anterior será el apuntado por inic

anterior ← 1

m[3].sig ← 2

m[1].sig ← 3

Eliminación de un elemento

Para eliminar un elemento de la lista deberemos recurrir al procedimiento suprimir(...), que, a su vez, llamará

al procedimiento liberar(...) para que inserte el elemento eliminado en la lista de vacíos.

Supongamos que se trata de eliminar el elemento marcado con ************* cuya posición es 3

posic ← 3

el elemento anterior al 3 ocupa en el array la posición 2

anterior ← 2

448 Fundamentos de programación

y el primer vacío está en 5. Siendo el aspecto actual de la lista el siguiente:

elemento sig

inic ← 1 1 XXXXXXXXXXXXX 2

anterior ← 2 2 XXXXXXXXXXXXX 3

posic ← 3 3 ************* 4

4 XXXXXXXXXXXXX 0

vacio ← 5 5 6

6 0

Al suprimir el elemento 3 la lista quedaría:

m[2].sig ← 4

mediante el procedimiento liberar(...) incluimos el nuevo vacio en la lista de vacíos

m[3].sig ← 5 vacio ← 3

como el que se suprime no es el primer elemento de la lista, el valor de inic no varía

inic ← 1

elemento sig

1 XXXXXXXXXXXXX 2

2 XXXXXXXXXXXXX 4

3 ************* 5

4 XXXXXXXXXXXXX 0

5 6

6 0

procedimiento liberar(E entero: posic; E/S arr: m; E/S entero: vacio)

inicio

m[posic].sig ← vacio

vacio ← posic

fin_procedimiento

procedimiento suprimir( E/S entero: inic, anterior, posic; E/S arr: m;

E/S entero: vacio)

inicio

si anterior = 0 entonces

inic ← m[posic].sig

si_no

m[anterior].sig ← m[posic].sig

fin_si

liberar(posic, m, vacio)

anterior ← 0 // Opcional

posic ← inic // Opcional

{ Las dos últimas instrucciones preparan los punteros para que,

si no se especifica otra cosa, la próxima eliminación se realice

por el principio de la lista }

fin_procedimiento

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 449

Recorrido de una lista

El recorrido de la lista se realizará siguiendo los punteros a partir de su primer elemento, el señalado por inic.

El procedimiento recorrer(...) que se implementa a continuación, al recorrer la lista va mostrando por pantalla los diferentes elementos que la componen.

procedimiento recorrer(E entero: inic)

var entero: posic

inicio

posic ← inic

mientras posic <> 0 hacer

{ Recurrimos a un procedimiento, proc_escribir(...),

para presentar por pantalla los campos del registro

pasado como parámetro }

proc_escribir(m[posic].elemento)

posic ← m[posic].sig

fin_mientras

fin_procedimiento

Búsqueda de un determinado elemento en una lista

El procedimiento consultar informará sobre si un determinado elemento se encuentra o no en la lista, la posición

que ocupa dicho elemento en el array y la que ocupa el elemento anterior. Si la información se encontrara colocada

en la lista de forma ordenada y creciente por el campo de búsqueda el procedimiento de consulta podría ser el siguiente:

procedimiento consultar( E entero: inic; S entero: posic, anterior;

E tipo_elemento: elemento; S lógico: encontrado;

E arr: m)

inicio

anterior ← 0

posic ← inic

{ Las funciones menor() e igual()comparan los registros por

un determinado campo}

mientras menor(m[posic].elemento,elemento) y (posic <> 0) hacer

anterior ← posic

posic ← m[posic].sig

fin_mientras

si(posic = 0) entonces

encontrado ← falso

si igual(m[posic].elemento,elemento) entonces

encontrado ← verdad

fin_procedimiento

Funciones

Cuando implementamos una lista enlazada utilizando arrays, necesitamos las siguientes funciones:

logico función vacia(E entero: inic)

inicio

devolver(inic = 0)

fin_función

lógico función llena(E entero: vacio)

inicio

devolver(vacio = 0)

fin_función

450 Fundamentos de programación

12.5. LISTAS CIRCULARES

Las listas simplemente enlazadas no permiten a partir de un elemento acceder directamente a cualquiera de los elementos que le preceden. En lugar de almacenar un puntero NULO en el campo SIG del último elemento de la lista, se

hace que el último elemento apunte al primero o principio de la lista. Este tipo de estructura se llama lista enlazada

circular o simplemente lista circular (en algunos textos se les denomina listas en anillo).

PRIMERO INFO SIG INFO SIG INFO SIG INFO SIG

Las listas circulares presentan las siguientes ventajas respecto de las listas enlazadas simples:

• Cada nodo de una lista circular es accesible desde cualquier otro nodo de ella. Es decir, dado un nodo se puede recorrer toda la lista completa. En una lista enlazada de forma simple sólo es posible recorrerla por completo si se parte de su primer nodo.

• Las operaciones de concatenación y división de listas son más eficaces con listas circulares.

Los inconvenientes, por el contrario, son:

• Se pueden producir lazos o bucles infinitos. Una forma de evitar estos bucles infinitos es disponer de un nodo

especial que se encuentre permanentemente asociado a la existencia de la lista circular. Este nodo se denomina

cabecera de la lista.

CABECERA SIG INFO SIG INFO SIG INFO SIG

Figura 12.7. Nodo cabecera de la lista.

El nodo cabecera puede diferenciarse de los otros nodos en una de las dos formas siguientes:

• Puede tener un valor especial en su campo INFO que no es válido como datos de otros elementos.

• Puede tener un indicador o bandera (flag) que señale cuando es nodo cabecera.

El campo de la información del nodo cabecera no se utiliza, lo que se señala con el sombreado de dicho campo.

Una lista enlazada circularmente vacía se representa como se muestra en la Figura 12.8.

CABECERA

Figura 12.8. Lista circular vacía.

12.6. LISTAS DOBLEMENTE ENLAZADAS

En las listas lineales estudiadas anteriormente el recorrido de ellas sólo podía hacerse en un único sentido: de izquierda a derecha (principio a final). En numerosas ocasiones se necesita recorrer las listas en ambas direcciones.

Las listas que pueden recorrerse en ambas direcciones se denominan listas doblemente enlazadas. En estas listas

cada nodo consta del campo INFO de datos y dos campos de enlace o punteros: ANTERIOR(ANT) y SIGUIENTE(SIG)

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 451

que apuntan hacia adelante y hacia atrás (Fig. 12.9). Como cada elemento tiene dos punteros, una lista doblemente enlazada ocupa más espacio en memoria que una lista simplemente enlazada para una misma cantidad de información.

La lista necesita dos punteros CABECERA y FIN2

que apuntan hacia el primero y último nodo.

La variable CABECERA y el puntero SIG permiten recorrer la lista en el sentido normal y la variable FIN y el

puntero ANT permiten recorrerla en sentido inverso.

NODO

ANT INFO SIG

(a

(b

IZQUIERDA DERECHA

Figura 12.9. Lista doblemente enlazada.

x x

CABECERA Campo INFO del nodo n FIN

Campo ANT del nodo n

Campo puntero SIG del nodo n

Nodo n

Figura 12.10. Lista doble.

Como se ve en la Figura 12.11, una propiedad fundamental de las listas doblemente enlazadas es que para cualquier puntero P de la lista:

nodo [nodo[p].sig].ant = p

nodo [nodo[p].ant].sig = p

p → ant

ant ant ant

p p → → sig

P

sig sig sig

Figura 12.11.

12.6.1. Inserción

La inserción de un nodo a la derecha de un nodo especificado, cuya dirección está dada por la variable M, puede

presentar varios casos:

1. La lista está vacía; se indica mediante M = NULO y CABECERA y FIN son también NULO. Una inserción indica

que CABECERA se debe fijar con la dirección del nuevo nodo y los campos ANT y SIG también se establecen

en NULO.

2. Insertar dentro de la lista: existe un elemento anterior y otro posterior de nuevo nodo.

3. Insertar a la derecha del nodo del fin de la lista. Se requiere que el apuntador FIN sea modificado.

2

Se adoptan estos términos a efectos de normalización, pero el lector puede utilizar IZQUIERDA y DERECHA.

452 Fundamentos de programación

CABECERA FIN

antes

M

CABECERA FIN

después x

Figura 12.12. Inserción en un lista doblemente enlazada.

CABECERA

antes

CABECERA

FIN

FIN

M

M

después

Figura 12.13. Inserción en el extremo derecho de una lista doblemente enlazada.

12.6.2. Eliminación

La operación de eliminación es directa. Si la lista tiene un simple nodo, entonces los punteros de los extremos izquierdo y derecho asociados a la lista se deben fijar en NULO. Si el nodo del extremo derecho de la lista es el señalado para la eliminación, la variable FIN debe modificarse para señalar el predecesor del nodo que se va a borrar de

la lista. Si el nodo del extremo izquierdo de la lista es el que se desea borrar, la variable CABECERA debe modificarse para señalar el elemento siguiente.

La eliminación se puede realizar dentro de la lista (Figura 12.14).

CABECERA FIN

antes

CABECERA FIN

ANT (X) X

X

después

Figura 12.14. Eliminación de un nodo X en una lista doblemente enlazada.

12.7. PILAS

Una pila (stack) es un tipo especial de lista lineal en la que la inserción y borrado de nuevos elementos se realiza

sólo por un extremo que se denomina cima o tope (top).

La pila es una estructura con numerosas analogías en la vida real: una pila de platos, una pila de monedas, una

pila de cajas de zapatos, una pila de camisas, una pila de bandejas, etc.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 453

Una pila

de bandejas

Una pila

de monedas

Una pila

de cajas

de zapatos

Una pila de camisas

Figura 12.15. Ejemplos de tipos de pilas.

Dado que las operaciones de insertar y eliminar se realizan por un solo extremo (el superior), los elementos sólo

pueden eliminarse en orden inverso al que se insertan en la pila. El último elemento que se pone en la pila es el

primero que se puede sacar; por ello, a estas estructuras se les conoce por el nombre de LIFO (last-in, first-out, último en entrar, primero en salir).

Las operaciones más usuales asociadas a las pilas son:

"push" Meter, poner o apilar: operación de insertar un elemento en la pila.

"pop" Sacar, quitar o desapilar: operación de eliminar un elemento de la pila.

Las pilas se pueden representar en cualquiera de las tres formas de la Figura 12.16.

FFF

EEE

DDD

CCC

BBB

AAA

Cima

(a)

AAA

BBB

CCC

DDD

EEE

FFF

Cima

(b)

AAA BBB CCC DDD EEE FFF

1 2 3 4 5 6 7 8 9 ... N – 1 N

Cima (c)

Figura 12.16. Representación de las pilas.

Para representar una pila St, se debe definir un vector con un determinado tamaño (longitud máxima):

var array [1..n] de <tipo_dato> : St

Se considerará un elemento entero P como el puntero de la pila (stack pointer). P es el subíndice del array correspondiente al elemento cima de la pila (esto es, el que ocupa la última posición). Si la pila está vacía, P = 0.

(Véase la figura de la página siguiente.)

En principio, la pila está vacía y el puntero de la pila o CIMA está a cero. Al meter un elemento en la pila, se

incrementa el puntero en una unidad. Al sacar un elemento de la pila se decrementa en una unidad el puntero.

Al manipular una pila se deben realizar algunas comprobaciones. En una pila vacía no se pueden sacar datos

(P = 0). Si la pila se implementa con un array de tamaño fijo, se puede llenar cuando P = n (n, longitud total de la

pila) y el intento de introducir más elementos en la pila producirá un desbordamiento de la pila.

454 Fundamentos de programación

}

1 2 4

...

n – 1 n

...

p – 1 p n – 2

Cima

(puntero de la pila)

Longitud

máxima de la pila

Parte no utilizada actualmente de la pila

3

Idealmente una pila puede contener un número ilimitado de elementos y no producir nunca desbordamiento. En

la práctica, sin embargo, el espacio de almacenamiento disponible es finito. La codificación de una pila requiere un

cierto equilibrio, ya que si la longitud máxima de la pila es demasiado grande se gasta mucha memoria, mientras que

un valor pequeño de la longitud máxima producirá desbordamientos frecuentes.

Para trabajar fácilmente con pilas es conveniente diseñar subprogramas de poner (push) y quitar (pop) elementos.

También es necesario con frecuencia comprobar si la pila está vacía; esto puede conseguirse con una variable o función booleana VACIA, de modo que cuando su valor sea verdadero la pila está vacía y falso en caso contrario.

P = CIMA Puntero de la pila.

VACIA Función booleana «pila vacía».

PUSH Subprograma para añadir, poner o insertar elementos.

POP Subprograma para eliminar o quitar elementos.

LONGMAX Longitud máxima de la pila.

X Elemento a añadir/quitar de la pila.

Implementación con punteros

Si el lenguaje tiene punteros, deberemos implementar las pilas con punteros.

Para la manipulación de una pila mediante punteros es preciso diseñar los siguientes procedimientos y/o funciones: inicializar o crear, apilar o meter, desapilar o sacar, consultarCima y Vacia.

algoritmo pilas_con_punteros

tipo

puntero_a nodo: punt

registro : tipo_elemento

.... : ....

.... : ....

fin_registro

registro : nodo

tipo_elemento : elemento

punt : cima

fin_registro

var

punt : cima

elemento : tipo_elemento

inicio

inicializar(cima)

...

fin

procedimiento inicializar(S punt: cima)

inicio

cima ← nulo

fin_procedimiento

lógico función vacia(E punt: cima)

inicio

devolver (cima = nulo)

fin_función

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 455

procedimiento consultarCima( E punt: cima;

S tipo_elemento: elemento)

inicio

si no vacia (cima) entonces

elemento ← cima→.elemento

fin_si

fin_procedimiento

Los elementos se incorporan siempre por un extremo, cima.

meter(cima, elemento)

xxx

nulo

nulo

yyy

cima

cima

cima →

elemento cima

cima →

elemento cima

auxi

auxi

zzz

1.º

2.º

3.º

nulo

cima

cima →

elemento cima

6.º

xxx

yyy

zzz

xxx

yyy

auxi

5.º

4.º

zzz

1.º cima apunta al último elemento de la pila.

2.º reservar(auxi).

3.º Introducimos la información en auxi→.elemento.

4.º Hacemos que auxi→.cima apunte a donde cima.

5.º Cambiamos cima para que apunte donde auxi.

6.º La pila tiene un elemento más.

456 Fundamentos de programación

procedimiento meter(E/S punt: cima; E tipo_elemento: elemento)

var

punt: auxi

inicio

reservar(auxi)

auxi→.elemento ← elemento

auxi→.cima ← cima

cima ← auxi

fin_procedimiento

Los elementos se recuperan en orden inverso a como fueron introducidos

Sacar(cima, elemento)

nulo

xxx

elemento cima

cima → cima →

yyy

auxi

1.º

2.º

zzz

cima

3.º

cima →

elemento cima

xxx

yyy

4.º

5.º

cima

auxi

zzz

cima →

elemento cima

1.º cima apunta al último elemento de la pila

2.º Hacemos que auxi apunte adonde apuntaba cima

3.º Y que cima pase a apuntar adonde cima→.cima

4.º liberar(auxi)

5.º La pila tiene un elemento menos

procedimiento sacar(E/S punt:cima; S tipo_elemento: elemento)

var

punt: auxi

inicio

si no vacia (cima) entonces

auxi ← cima

elemento ← cima →.elemento

cima ← cima →.cima

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 457

liberar(auxi)

{liberar es un procedimiento para la eliminación de

variables dinámicas}

fin_si

fin_procedimiento

Implementación con arrays

Necesitaremos un array y una variable numérica cima que apunte al último elemento colocado en la pila.

La inserción o extracción de un elemento se realizará siempre por la parte superior.

Su implementación mediante arrays limita el máximo número de elementos que la pila puede contener y origina

la necesidad de una función más.

Llena(...) de resultado lógico

cima ←0

Inicializar(cima)

cima 1

Meter(cima,p,elemento)

cima ←2

xxxxxxxx

xxxxxxxx

xxxxxxxx cima ←1 xxxxxxxx

Sacar(cima,p,elemento)

Max

...

...

3

2

1

xxxxxxxx

←

const Max = <expresión>

tipo

registro: tipo_elemento

... : ...

... : ...

fin_registro

array[1..Max] de tipo_elemento: arr

var

entero : cima

arr : p

tipo_elemento : elemento

inicio

inicializar(cima)

...

fin

procedimiento inicializar(S entero: cima)

inicio

cima ← 0

fin_procedimiento

logico función vacia(E entero: cima)

inicio

si cima = 0 entonces

458 Fundamentos de programación

devolver (verdad)

si_no

devolver (falso)

fin_si

fin_función

lógico función llena(E entero: cima)

inicio

si cima = Max entonces

devolver (verdad)

si_no

devolver (falso)

fin_si

fin_función

procedimiento consultarCima( E entero: cima; E arr:p;

S tipo_elemento: elemento)

inicio

si no vacia (cima) entonces

elemento ← p[cima]

fin_si

fin_procedimiento

procedimiento meter( E/S entero: cima; E/S arr: p;

E tipo_elemento: elemento)

inicio

si no llena (cima) entonces

cima ← cima + 1

p[cima] ← elemento

fin_si

fin_procedimiento

procedimiento sacar( E/S entero: cima; E arr: p;

S tipo_elemento: elemento)

inicio

si no vacia (cima) entonces

elemento ← p[cima]

cima ← cima - 1

fin_si

fin_procedimiento

12.7.1. Aplicaciones de las pilas

Las pilas son utilizadas ampliamente para solucionar una amplia variedad de problemas. Se utilizan en compiladores,

sistemas operativos y en programas de aplicación. Veamos algunas de las aplicaciones más interesantes.

Llamadas a subprogramas

Cuando dentro de un programa se realizan llamadas a subprogramas, el programa principal debe recordar el lugar

donde se hizo la llamada, de modo que pueda retornar allí cuando el subprograma se haya terminado de ejecutar.

Supongamos que tenemos tres subprogramas llamados A, B y C, y supongamos también que A invoca a B y B

invoca a C. Entonces B no terminará su trabajo hasta que C haya terminado y devuelto su control a B. De modo

similar, A es el primero que arranca su ejecución, pero es el último que la termina, tras la terminación y retorno

de B.

Esta operación se consigue disponiendo las direcciones de retorno en una pila.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 459

Programa principal

X

Y

Z Subprograma A

Subprograma A

fin _ subprograma A

fin _ subprograma B

fin _ subprograma C

Subprograma C

Subprograma B

Subprograma B

Subprograma C

Puntero de pila

Pila de direcciones

de retorno

Programa principal

llamar _ a A

llamar _ a B

direccion X

direccion Y

direccion Z

llamar a C

fin

Cuando un subprograma termina, debe retornar a la dirección siguiente a la instrucción que le llamó (llamar_a).

Cada vez que se invoca un subprograma, la dirección siguiente (X, Y o Z) se introduce en la pila. El vaciado de la

pila se realizará por los sucesivos retornos, decrementándose el puntero de pila que queda libre apuntando a la siguiente dirección de retorno.

←Puntero de pila (P)

X

Y

Z

X

Y

X ← P

Retorno a

subprograma B

Retorno a

subprograma A

Retorno a

programa principal

← P

← P

EJEMPLO 12.6

Se desea leer un texto y separar los caracteres letras, dígitos y restantes caracteres para ser utilizados posteriormente.

Utilizaremos tres pilas (LETRAS, DIGITOS, OTROSCAR) para contener los diferentes tipos de caracteres. El

proceso consiste en leer carácter a carácter, comprobar el tipo de carácter y según el resultado introducirlo en su pila

respectiva.

algoritmo lecturacaracter

const Max = <valor>

tipo

array [1..Max] de carácter:pila

var

entero : cima1, cima2, cima3

460 Fundamentos de programación

pila : pilaletras, piladigitos, pilaotroscaracteres

carácter : elemento

inicio

crear (cima1)

crear (cima2)

crear (cima3)

elemento ← leercar

mientras (codigo(elemento)<> 26) y no llena(cima1) y no

llena(cima2)y no llena(cima3) hacer

{saldremos del bucle en cuanto se llene alguna de las pilas o

pulsemos ^Z}

si (elemento >= 'A') y (elemento <= 'Z') o (elemento >= 'a') y

(elemento >= 'z')entonces

meter (cima1, pilaletras, elemento)

si_no

si (elemento>= '0') y (elemento<='9') entonces

meter (cima2, piladigitos, elemento)

si_no

meter (cima3, pilaotroscaracteres, elemento)

fin_si

fin_si

elemento ← leercar

fin_mientras

fin

procedimiento crear (S entero: cima)

inicio

cima ← 0

fin_procedimiento

lógico función llena (E entero: cima)

inicio

devolver (cima = Max)

fin_función

procedimiento meter(E/S entero: cima; E/S tipo_elemento: elemento)

inicio

cima ← cima+1

p [cima] ← elemento

fin_procedimiento

12.8. COLAS

Las colas son otro tipo de estructura lineal de datos similar a las pilas, diferenciándose de ellas en el modo de insertar/eliminar elementos.

Una cola (queue) es una estructura lineal de datos

var array [1..n] de <tipo_dato> : C

en la que las eliminaciones se realizan al principio de la lista, frente (front), y las inserciones se realizan en el otro

extremo, final (rear). En las colas el elemento que entró el primero sale también el primero; por ello se conoce como

listas FIFO (first-in, first-out, “primero en entrar, primero en salir”). Así, pues, la diferencia con las pilas reside en

el modo de entrada/salida de datos; en las colas las inserciones se realizan al final de la lista, no al principio. Por ello

las colas se usan para almacenar datos que necesitan ser procesados según el orden de llegada.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 461

Eliminación Inserción

Frente Final

x[1] x[2] x[3] x[n – 1] x[n]

.....

En la vida real se tienen ejemplos numerosos de colas: la cola de un autobús, la cola de un cine, una caravana de

coches en una calle, etc. En todas ellas el primer elemento (pasajero, coche, etc.) que llega es el primero que sale.

En informática existen también numerosas aplicaciones de las colas. Por ejemplo, en un sistema de tiempo compartido suele haber un procesador central y una serie de periféricos compartidos: discos, impresoras, etc. Los recursos se comparten por los diferentes usuarios y se utiliza una cola para almacenar los programas o peticiones de los

diferentes usuarios que esperan su turno de ejecución. El procesador central atiende —normalmente— por riguroso

orden de llamada del usuario; por tanto, todas las llamadas se almacenan en una cola. Existe otra aplicación muy

utilizada que se denomina cola de prioridades; en ella el procesador central no atiende por riguroso orden de llamada, aquí el procesador atiende por prioridades asignadas por el sistema o bien por el usuario, y sólo dentro de las

peticiones de igual prioridad se producirá una cola.

12.8.1. Representación de las colas

Las colas se pueden representar por listas enlazadas o por arrays.

Se necesitan dos punteros: frente(f) y final(r), y la lista o array de n elementos (LONGMAX).

1 2 f–1 f f+1 r–1 r r+1 n–2 n–1 n

Parte no utilizada de la lista Cola Parte no utilizada de la lista

si la cola está vacía frentre = nulo o bien f ← 0

eliminar elementos frentre ← frentre + 1 o bien f ← f + 1

añadir elementos final ← final + 1 o bien f ← r + 1

La Figura 12.17 muestra la representación de una cola mediante un array o mediante una lista enlazada.

Las operaciones que se pueden realizar con una cola son:

(b) final

[1] [2] [3] [4]

100 264 119 48

(a)

100 264 119 48

frente

frente

final

Figura 12.17. Representación de una cola: (a) mediante una lista enlazada; (b) mediante un array.

462 Fundamentos de programación

• Acceder al primer elemento de la cola.

• Añadir un elemento al final de cola.

• Eliminar el primer elemento de la cola.

• Vaciar la cola.

• Verificar el estado de la cola: vacía o llena.

Implementación con estructuras dinámicas

Aunque, como posteriormente veremos, las colas se pueden simular mediante un array y dos variables numéricas

(frente, final), deberemos, si el lenguaje lo permite, implementarlas mediante punteros.

En una cola las eliminaciones se realizarán por el extremo denominado frente y las inserciones por el final.

Para la manipulación de una cola necesitaremos los subprogramas: inicializar o crear, consultarPrimero, poner o meter, quitar o sacar y vacia o colaVacia y los siguientes tipos de datos:

tipo

puntero_a nodo : punt

registro : tipo_elemento

... : ....

... : ....

fin_registro

registro : nodo

tipo_elemento : elemento

punt : sig

fin_registro

var

punt : frente, final

tipo_elemento : elemento

Cuando no hay elementos en la cola

frente ← nulo final ← nulo

de lo que deducimos

procedimiento inicializar(S punt: frente, final)

inicio

frente ← nulo

final ← nulo

fin_procedimiento

Meter(final, frente, elemento)

procedimiento meter( E/S punt: final; S punt: frente;

E tipo_elemento: elemento)

var

punt: auxi

inicio

reservar(auxi)

auxi→.elemento ← elemento

auxi→.sig ← nulo

si final = nulo entonces

frente ← auxi

si_no

final→.sig ← auxi

fin_si

final ← auxi

fin_procedimiento

Sacar(frente,final,elemento)

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 463

final →

elemento

xxx

yyy

final

auxi

zzz

5.º

sig

xxx

yyy

final

auxi

nulo

nulo

nulo

nulo

zzz

6.º

auxi →

elemento si g

xxx

frente

frente

frente

yyy

2.º

auxi

1.º

final

auxi

3.º zzz

4.º

Los pasos de la operación meter ():

1.º Situación de partida

2.º reservar (auxi)

3.º Introducir la nueva información en auxi →.elemento

4.º Hacer que auxi →.sig apunte a nulo

5.º Conseguir que final →.sig apunte a donde lo hace auxi

6.º Por último, final debe apuntar también a donde auxi

464 Fundamentos de programación

Imaginemos que la cola tiene un único elemento. Los elementos se extraen siempre por el frente.

1.º

xxxxxxxxxxxxxx

frente

final

nulo

nulo

3.º

xxxxxxxxxxxxxx

frente

final

auxi

2.º

1.º Estado inicial.

2.º Hacemos que auxi apunte donde lo hace frente.

3.º Extraemos la información de auxi →.elemento.

6.º

xxxxxxxxxxxxxx

frente

final

auxi

4.º

xxxxxxxxxxxxxx

frente

final

auxi

5.º nulo

nulo

4.º Hacemos que frente apunte a donde lo hace auxi →.sig.

5.º Como frente toma el valor nulo a final le damos nulo.

6.º Liberar(auxi).

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 465

procedimiento sacar( E/S punt: frente; S punt: final;

S tipo_elemento: elemento)

var

punt: auxi

inicio

auxi ← frente

elemento ← auxi→.elemento

frente ← frente→.sig

si frente = nulo entonces

final ← nulo

fin_si

liberar(auxi)

fin_procedimiento

Como los elementos se extraen siempre por el frente, la cola estará vacía cuando

frente = nulo

lógico función vacia(E punt: frente)

inicio

si frente = nulo entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

procedimiento consultarPrimero( E punt: frente; S tipo_elemento: elemento)

inicio

si no vacia (frente) entonces

elemento ← frente→.elemento

fin_sin

fin_procedimiento

Implementación utilizando estructuras de tipo array

Podemos representar las colas mediante arrays.

frente final Max

const

Max = <expresión> //longitud máxima

tipo

registro: tipo_elemento

... : ...

... : ...

fin_registro

array[1..Max] de tipo_elemento: arr

var

entero : frente, final

arr : c //la cola se define como un array

tipo_elemento : elemento

466 Fundamentos de programación

Cuando la cola esté vacía frente ← 0 final ← 0

procedimiento inicializar(S entero: frente,final)

inicio

frente ← 0

final ← 0

fin_procedimiento

El procedimiento para la inserción de un nuevo elemento deberá verificar, en primer lugar, que la cola no está

totalmente llena y, por consiguiente, no se producirá error de desbordamiento. La condición de desbordamiento se

produce cuando final = Max

procedimiento meter( E/S entero: final; S entero: frente;

E/S arr: c; E tipo_elemento: elemento)

inicio

si final = 0 entonces

frente ← 1

fin_si

final ← final + 1

c[final] ← elemento

fin_procedimiento

Para eliminar un elemento será preciso verificar, en primer lugar, que la cola no está vacía.

procedimiento sacar( E/S entero: frente,final; E arr: c;

S tipo_elemento: elemento)

inicio

si no vacia (frente) entonces

elemento ← c[frente]

frente ← frente + 1

si frente = final + 1 entonces

frente ← 0

final ← 0

fin_si

fin_si

fin_procedimiento

La cola estará vacía cuando frente = 0

lógico función vacia(E entero: frente)

inicio

devolver(frente = 0)

fin_función

Esta implementación tiene el inconveniente de que puede ocurrir que la variable final llegue al valor máximo

de la tabla, con lo cual no se puedan seguir añadiendo elementos a la cola, aun cuando queden posiciones libres a la

izquierda de la posición frente por haber sido eliminados algunos de sus elementos.

frente final

Existen diversas soluciones a este problema:

1.º Retroceso.

Consiste en mantener fijo a 1 el valor de frente, realizando un desplazamiento de una posición para todas

las componentes ocupadas cada vez que se efectúa una supresión.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 467

2.º Reestructuración.

Cuando final llega al máximo de elementos se desplazan las componentes ocupadas hacia atrás las posiciones necesarias para que el principio coincida con el principio de la tabla.

3.º Mediante un array circular.

Un array circular es aquel en el que se considera que la componente primera sigue a la componente última.

Esta implementación obliga a dejar siempre una posición libre para separar el principio y el final del array.

Evidentemente, seguirá existiendo la limitación de que pueda llenarse completamente el array, Max-1

posiciones ocupadas.

12.8.2. Aprovechamiento de la memoria

El mejor método para evitar el desaprovechamiento de espacio es el diseño de la cola mediante un array circular.

yyy

xxx

Max

5

4

3

2

1

final ← 6

frente 4 ← frente 4 ←

frente 5 ←

frente 6 ←

final 1 ← final 1 ← final 1 ←

final 1 ←

frente 1 ←

1.o

Imaginamos

la siguiente

situación de partida

2.o

Introducción

de un nuevo

elemento

3.o

Extracción

de un

elemento

4.o

Extracción

de otro

5.o

Extracción

del último,

cola vacía

yyy

xxx

zzz

yyy

zzz

xxx

zzz

xxx

yyy

xxx

zzz

yyy

Deberemos efectuar las siguientes declaraciones:

const Max = <expresión>

tipo

registro : tipo_elemento

... : ...

... : ...

fin_registro

array[1..Max] de tipo_elemento : arr

var

entero : frente, final

arr : c

tipo_elemento : elemento

En c[frente] estará siempre libre, sirviendo para separar el principio y el final del array.

procedimiento inicializar(S entero: frente,final)

inicio

frente ← 1

final ← 1

fin_procedimiento

468 Fundamentos de programación

Los elementos se añaden por el final.

procedimiento meter(E/S entero:final; E/S arr: c;E tipo_elemento: elemento)

inicio

final ← final mod max + 1

c[final] ← elemento

fin_procedimiento

Los elementos se eliminan por el frente. El elemento a eliminar se encuentra siempre en la posición del array

siguiente a la especificada por frente.

procedimiento sacar(E/S entero: frente; E arr: c;

S tipo_elemento: elemento)

inicio

elemento ← c[frente mod max + 1]

frente ← frente mod max + 1

fin_procedimiento

logico función vacia(E entero: frente,final)

inicio

si frente = final entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

Cuando la posición siguiente a final sea frente no podremos añadir más información, pues habría que hacerlo en

c[final mod max + 1] es decir c[frente]

y la cola se encontrará llena

logico función llena(E entero: frente,final)

inicio

si frente = (final mod Max + 1!) entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

procedimiento consultarPrimero(E entero: frente; E arr: c; S tipo_elemento: elemento)

inicio

elemento ← c[frente mod max + 1]

fin_procedimiento

Con esta estrategia, array circular, se sacrifica un elemento del array para distinguir la cola llena de cola vacía.

12.9. DOBLE COLA

Existe una variante de la cola simple estudiada anteriormente y que es la doble cola. La doble cola o bicola es una

cola bidimensional en la que las inserciones y eliminaciones se pueden realizar en cualquiera de los dos extremos de

la lista.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 469

Frente Fondo

Eliminación

Eliminación

Inserción

Inserción

Figura 12.18. Doble cola (bicola).

Existen dos variantes de la doble cola:

• Doble cola de entrada restringida: acepta inserciones sólo al final de la cola.

• Doble cola de salida restringida: acepta eliminaciones sólo al frente de la cola.

Inserción

IZQ = 5

DCHA = 25

Eliminación

x

5 25

x

Los procedimientos de inserción y eliminación de las dobles colas son variantes de los procedimientos estudiados

para las colas simples y se dejan como ejercicio al lector.

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

12.1. Una tienda de artículos deportivos desea almacenar en una lista enlazada, con un único elemento por producto, la

siguiente información sobre las ventas realizadas: Código del artículo, Cantidad y Precio. Usando estructuras de

tipo array, desarrollar un algoritmo que permita tanto la creación de la lista como su actualización al realizarse

nuevas ventas o devoluciones de un determinado producto.

Análisis del problema

El algoritmo contemplará la creación de la lista y colocará los elementos clasificados por código para que las búsquedas

puedan resultar algo más rápidas. Al producirse una venta se han de considerar las siguientes posibilidades:

• Es la primera vez que se vende ese artículo y esto nos lleva a la inserción de un nuevo elemento en la lista.

• Ya se ha vendido alguna otra vez dicho artículo; por tanto, es una modificación de un elemento de la lista, incrementándose la cantidad vendida.

Una devolución nos hará pensar en las siguientes situaciones:

• El comprador devuelve parte de lo que se había vendido de un determinado artículo, lo que representa una modificación de la cantidad vendida, decrementándose con la devolución.

• Se devuelve todo lo que se lleva vendido de un determinado artículo y, en consecuencia, el producto debe desaparecer de la lista de ventas.

Diseño del algoritmo

algoritmo ejercicio_12_1

const

max = ...

tipo

registro : tipo_elemento

cadena: cod

entero: cantidad

real: precio

fin_registro

470 Fundamentos de programación

registro : tipo_nodo

tipo_elemento: elemento

entero: sig

fin_registro

array[1..Max] de tipo_nodo: lista

var

entero: inic,vacio

lista: m

carácter: opcion

inicio

iniciar(m, vacio)

inicializar(inic)

repetir

escribir('1.- Ventas')

escribir('2.- Devoluciones')

escribir('3.- Mostrar lista')

escribir('4.- Fin')

escribir('Elija opcion')

leer(opcion)

según_sea opcion hacer

'1':nuevasventas(inic,vacio,m)

'2':devoluciones(inic,vacio,m)

'3':recorrer(inic,m)

fin_según

hasta_que opcion='4'

fin

procedimiento inicializar(S entero: inic);

inicio

inic ← 0

fin_procedimiento

lógico función vacia(E entero: inic)

inicio

devolver(inic = 0)

fin_función

procedimiento iniciar( E/S lista: m; E/S entero: vacio)

var

entero: i

inicio

vacio ← 1

desde i ← 1 hasta Max-1 hacer

m[i].sig ← i+1

fin_desde

m[Max].sig ← 0

fin_procedimiento

procedimiento reservar(S entero: auxi; E lista: m; E/S entero: vacio)

inicio

si vacio = 0 entonces

escribir('Memoria agotada')

auxi ← 0

si_no

auxi ← vacio

vacio ← m[vacio].sig

fin_si

fin_procedimiento

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 471

lógico funcion llena(E entero: vacio)

inicio

devolver(vacio = 0)

fin_función

procedimiento consultar(E entero: inic; S entero: posic, anterior;

E tipo_elemento: elemento; S lógico: encontrado;

E lista: m)

inicio

si no vacia (inic) entonces

anterior ← 0

posic ← inic

mientras (m[posic].elemento.cod < elemento.cod) y (posic<>0) hacer

anterior ← posic

posic ← m[posic].sig

fin_mientras

si m[posic].elemento.cod = elemento.cod entonces

encontrado ← verdad

si_no

encontrado ← falso

fin_si

fin_si

fin_procedimiento

procedimiento insertar(E/S entero: inic,anterior;

E tipo_elemento: elemento;

E/S lista: m; E/S entero: vacio)

var

entero: auxi

inicio

si no llena (vacio) entonces

reservar(auxi,m,vacio)

m[auxi].elemento ← elemento

si anterior=0 entonces

m[auxi].sig ← inic

inic ← auxi

si_no

m[auxi].sig ← m[anterior].sig

m[anterior].sig ← auxi

fin_si

anterior ← auxi

fin_si

fin_procedimiento

procedimiento escribir_reg(E tipo_elemento: e)

inicio

escribir(e.cod)

escribir(e.cantidad)

escribir(e.precio)

fin_procedimiento

procedimiento recorrer(E entero: inic; E lista: m)

var

entero: posic

inicio

posic ← inic

mientras posic<>0 hacer

escribir_reg(m[posic].elemento)

posic ← m[posic].sig

fin_mientras

fin_procedimiento

472 Fundamentos de programación

procedimiento liberar(E/S entero: posic; E/S lista: m;

E/S entero: vacio)

inicio

m[posic].sig ← vacio

vacio ← posic

fin_procedimiento

procedimiento suprimir(E/S entero: inic, anterior, posic;

E/S lista: m; E/S entero: vacio)

inicio

si anterior=0 entonces

inic ← m[posic].sig

si_no

m[anterior].sig ← m[posic].sig

fin_si

liberar(posic,m,vacio)

anterior ← 0

posic ← inic

fin_procedimiento

procedimiento nuevasventas(E/S entero: inic, vacio; E/S lista: m)

var

tipo_elemento: elemento

lógico: encontrado

entero: anterior, posic

inicio

repetir

escribir('Introduzca * en el código para terminar')

escribir('Código: ')

leer(elemento.cod)

si elemento.cod <>'*' entonces

si vacia(inic) entonces

anterior ← 0

escribir('Cantidad: ')

leer(elemento.cantidad)

escribir('Precio: ')

leer(elemento.precio)

insertar(inic,anterior,elemento,m,vacio)

si_no

consultar(inic,posic,anterior,elemento,encontrado,m)

si no encontrado entonces

si no llena(vacio) entonces

escribir('Cantidad: ')

leer(elemento.cantidad)

escribir('Precio: ')

leer(elemento.precio)

insertar(inic,anterior,elemento,m,vacio)

si_no

escribir('Llena')

fin_si

si_no

escribir('Cantidad: ')

leer(elemento.cantidad)

m[posic].elemento.cantidad ← m[posic].elemento.cantidad+

elemento.cantidad

fin_si

fin_si

fin_si

hasta_que elemento.cod = '*'

fin_procedimiento

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 473

procedimiento devoluciones( E/S entero: inic, vacio; E/S lista: m)

var

tipo_elemento: elemento

entero : posic, anterior

entero : cantidad

lógico : encontrado

inicio

si no vacia(inic) entonces

escribir('Introduzca un * en el código para terminar')

escribir('Código: ')

leer(elemento.cod)

si_no

escribir('No hay ventas, no puede haber devoluciones')

fin_si

mientras (elemento.cod<>'*' ) y no vacia(inic) hacer

consultar(inic, posic, anterior, elemento, encontrado, m)

si encontrado entonces

repetir

escribir('Deme cantidad devuelta ')

leer(cantidad)

si cantidad > m[posic].elemento.cantidad entonces

escribir('Error')

fin_si

hasta_que cantidad <= m[posic].elemento.cantidad

m[posic].elemento.cantidad ← m[posic].elemento.cantidad-cantidad

si m[posic].elemento.cantidad=0 entonces

suprimir(inic,anterior,posic,m,vacio)

fin_si

si_no

escribir('No existe')

fin_si

si no vacia(inic) entonces

escribir('Introduzca un * en el código para terminar')

leer(elemento.cod)

si_no

escribir('No hay ventas, no puede haber devoluciones')

fin_si

fin_mientras

fin_procedimiento

12.2. Diseñar un procedimiento que realice una copia de una pila en otra.

Análisis del problema

Entendemos por copiar la acción de rellenar otra pila con los mismos elementos y en el mismo orden. Por lo tanto, si simplemente sacamos los elementos de la pila y los metemos en otra, tendrá los mismos elementos, pero en orden distinto.

Tenemos dos soluciones, una sería utilizar una pila auxiliar: sacaremos los elementos de la pila principal y los meteremos

en la auxiliar, para después volcarlos en dos pilas, una de las cuales es la de salida. La otra solución sería recursiva: se

sacan los elementos de la pila mediante llamadas recursivas; cuando la pila esté vacía inicializaremos la copia y a la vuelta de la recursividad se van introduciendo los elementos en dos pilas en orden inverso a como han salido.

Observe que el procedimiento valdrá tanto para la implementación con arrays como con estructuras dinámicas de datos.

Diseño del algoritmo

Solución iterativa

procedimiento CopiarPila(E/S pila: p; S pila: copia)

var

pila: aux

tipo_elemento: e

474 Fundamentos de programación

inicio

PilaVacia(aux)

mientras no EsPilaVacia(p) hacer

Tope(p,e) "extra el primer elemento sin borrado

PInsertar(aux,e) "inserta elemento

PBorrar(p) "borra elemento

fin_mientras

PilaVacia(copia)

mientras no EsPilaVacia(aux) hacer

Tope(aux,e)

PInsertar(copia, e)

PInsertar(p, e)

PBorrar(aux)

fin_mientras

fin_procedimiento

Solución recursiva (la recursividad se estudia en el Capítulo 14)

procedimiento CopiarPilaR(E/S pila: p, copia)

var

tipo_elemento: e

inicio

si no EsPilaVacia(p) entonces

Tope(p,e)

PBorrar(p)

CopiarPila(p, copia)

PInsertar(copia, e)

Pinsertar(p, e)

si_no

PilaVacia(copia)

fin_si

fin_procedimiento

Los procedimientos y funciones utilizados implementados con punteros son

procedimiento PilaVacia(S pila: p)

inicio

p ← nulo

fin_procedimiento

lógico function EsPilaVacia(E pila: p)

inicio

devolver(p = nulo)

fin_función

procedimiento PInsertar(E/S pila: p; E tipo_elemento: e)

var

pila: aux

inicio

reservar(aux)

aux→.info ← e

aux→.cimaant ← p

p ← aux

fin_procedimiento

procedimiento PBorrar(E/S pila: p)

var

pila: aborrar

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 475

inicio

Si no EsPilaVacia (p) entonces

aborrar ← p

p ← p→.cimaant

liberar(aborrar)

fin_sin

fin_procedimiento

procedimiento Tope(E pila: p; S tipo_elemento: e)

inicio

e ← p→.info

fin_procedimiento

12.3. Diseñar un procedimiento que elimine el elemento enésimo de una pila.

Análisis del problema

También en este caso se debe utilizar una pila auxiliar o recursividad para poder restaurar los elementos en el mismo orden.

Es necesario borrar elementos e insertarlos en la pila auxiliar hasta llegar al elemento n. En ese punto, se sacan todos los

elementos de la pila auxiliar y se introducen en la pila original. Obsérvese que también en este caso es totalmente indistinto utilizar estructuras de datos dinámicas o estáticas.

Diseño del algoritmo

Solución iterativa

procedimiento BorrarElementoN(E/S pila: p; E entero: n)

var

pila: aux

tipo_elemento: e

entero: i

inicio

i ← 1

PilaVacia(aux)

mientras no EsPilaVacia(p) y (i<n) hacer

i ← i+1

Tope(p, e)

PInsertar(aux, e)

PBorrar(p)

fin_mientras

Pborrar(p)

mientras no EsPilaVacia(aux) hacer

Tope(aux, e)

PInsertar(p, e)

PBorrar(aux)

fin_mientras

fin_procedimiento

Solución recursiva

procedimiento BorrarElementoN(E/S pila: p; E entero: n)

var

tipo_elemento: e

inicio

si (n>1) y no EsPilaVacia(p) entonces

tope(p,e)

PBorrar(p)

BorrarElementoN(p, n-1)

PInsertar(p,e)

si_no

PBorrar(p)

fin_si

fin_procedimiento

476 Fundamentos de programación

12.4. Diseñar un algoritmo para, utilizando pilas y colas, comprobar si una frase es un palíndromo (un palíndromo es

una frase que se lee igual de izquierda a derecha que de derecha a izquierda).

Análisis del problema

Se puede aprovechar el distinto orden en que salen los elementos de una pila y una cola para averiguar si una frase es igual

a ella misma invertida. Para ello, una vez introducida la frase, se insertan en una pila y una cola todos los caracteres (se evitarán los signos de puntuación, y se podría mejorar si se convierten todos los caracteres a mayúsculas o minúsculas y se eliminan los acentos).

A continuación se van sacando elementos de la pila y de la cola. Si aparece algún carácter distinto, es que la frase no

es igual a ella misma invertida y, por lo tanto, no será un palíndromo. Si al acabar de sacar los elementos, todos han sido

iguales, se trata de un palíndromo.

Diseño del algoritmo

algoritmo ejercicio_12_4;

{Aquí deberían incluirse las declaraciones, procedimientos y funciones

para trabajar con pilas y colas.

Es indistinto trabajar con estructuras estáticas o dinámicas}

var

pila : p

cola : c

cadena : car1, car2, frase

entero : i

inicio

ColaVacia(c)

PilaVacia(p)

leer(frase)

desde i ← 1 hasta longitud(frase) hacer

car1 ← subcadena(frase, i, 1)

{si no es un signo de puntuación}

si posicion(car1,',:;.')= 0 entonces

CInsertar(c,car1)

PInsertar(p,car1)

fin_si

fin_desde

repetir

Primero(c,car1)

Tope(p,car2)

PBorrar(p)

CBorrar(c)

hasta_que (car1<>car2) o EsColaVacia(c)

si car1=car2 entonces

escribir('Es un palíndromo')

si_no

escribir('No es un palíndromo')

fin_si

fin

CONCEPTOS CLAVE

• Apuntador.

• Cola.

• Doble cola.

• Enlace.

• Estructura de datos dinámica.

• Estructura de datos estática.

• Lista circular.

• Lista doblemente enlazada.

• Lista enlazada.

• Pila.

• Puntero.

Estructuras dinámicas lineales de datos (pilas, colas y listas enlazadas) 477

RESUMEN

Una lista lineal es una lista en la que cada elemento tiene

un único sucesor. Las operaciones típicas en una lista lineal

son: inserción, supresión, recuperación y recorrido.

Una lista enlazada es una colección ordenada de datos

en los que cada elemento contiene la posición (dirección)

del siguiente elemento. Es decir, cada elemento (nodo) de

la lista contiene dos parte: datos y enlace (puntero).

Una lista simplemente enlazada contiene sólo un enlace a un sucesor único a menos que sea el último, en cuyo

caso no se enlaza con ningún otro nodo. Cuando se desea

insertar un elemento en una lista enlazada, se deben considerar dos casos: añadir al principio y añadir en el interior o

añadir al final. Si se desea eliminar un nodo de una lista se

deben considerar dos casos: eliminar el primer nodo y eliminar cualquier otro nodo. El recorrido de una lista enlazada implica visitar cada nodo de la lista y procesar en su caso.

Una lista doblemente enlazada es una lista en la que

cada nodo tiene un puntero a su sucesor y otro a su predecesor. Una lista enlazada circularmente es una lista en

la que el enlace del último nodo apunta al primero de la

lista.

Una pila es una estructura de datos tipo LIFO (last-in,

first-out, último en entrar, primero en salir) en la que los

datos se insertan y eliminan por el mismo extremo que se

denomina cima de la pila. Se definen diferentes operaciones: crear, apilar, desapilar, pilaVacía, pilaLlena, cimaPila.

Una cola (FIFO, first-in, first-out) es una lista lineal en

la que los datos se pueden insertar por un extremo denominado Cabeza y se elimina o borra por el otro extremo denominado Cola o Final. Las operaciones básicas de una

cola son: poner, quitar, frenteCola y Colavacia,

Colallena.

Las pilas y las colas se pueden implementar mediante

arrays y mediante listas enlazadas.

EJERCICIOS

12.1. Dada una lista lineal cuya estructura de nodos consta de los campos INFO y ENLACE, diseñar un algoritmo que cuente el número de nodos de la lista.

12.2. Diseñar un algoritmo que cambie el campo INFO del

n-ésimo nodo de una lista enlazada simple por un

valor dado x.

12.3. Dadas dos listas enlazadas, cuyos nodos frontales se

indican por los apuntadores PRIMERO y SEGUNDO,

respectivamente, realizar un algoritmo que una ambas listas. El nodo frontal de la lista nueva se almacenará en TERCERO.

12.4. Se dispone de una lista enlazada DEMO 1 almacenada

en memoria. Realizar un algoritmo que copie la lista DEMO 1 en otra denominada DEMO 2.

12.5. Escribir un algoritmo que realice una inserción contigua a la izquierda del n-ésimo nodo de una lista

enlazada y repetir el ejercicio para una inserción

también contigua a la derecha de n-ésimo nodo.

12.6. Escribir un algoritmo que divida una lista enlazada

determinada en dos listas enlazadas independientes.

El primer nodo de la lista principal es PRIMERO y la

variable PARTIR es la dirección del nodo que se convierte en el primero de los nodos de la segunda lista

enlazada resultante.

12.7. Como aplicación de pilas, obtener un subalgoritmo

función recursiva de la función de Ackermann.

Función de Ackermann

A(m, n) = { n + 1 si m = 0

A(m – 1,1) si n = 0

A(m – 1) A(m, n – 1) restantes casos

12.8. Escribir un subalgoritmo que permita insertar un

elemento en una doble cola —representada por un

vector—. Tengan en cuenta que debe existir un parámetro que indique el extremo de la doble cola en

que debe realizarse la inserción.

12.9. Realizar un algoritmo que cuente el número de

nodos de una lista circular que tiene una cabecera.

12.10. Diseñar un algoritmo que inserte un nodo al final

de una lista circular.

CAPÍTULO 13

Estructura de datos no lineales

(árboles y grafos)

13.1. Introducción

13.2. Árboles

13.3. Árbol binario

13.4. Árbol binario de búsqueda

13.5. Grafos

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

CONCEPTOS CLAVE

RESUMEN

EJERCICIOS

Las estructuras dinámicas lineales de datos —listas

enlazadas, pilas y colas— tienen grandes ventajas de

flexibilidad sobre las representaciones contiguas; sin

embargo, tienen un punto débil: son listas secuenciales, es decir, están dispuestas de modo que es necesario moverse a través de ellas una posición cada vez

(cada elemento tiene un siguiente elemento). Esta linealidad es típica de cadenas, de elementos que pertenecen a una sola dimensión: campos en un registro,

entradas en una pila, entradas en una cola y de nodos

en una lista enlazada simple. En este capítulo se tratarán las estructuras de datos no lineales que resuelven los problemas que plantean las listas lineales y en

las que cada elemento puede tener diferentes “siguientes” elementos, que introducen el concepto de

estructuras de bifurcación. Estos tipos de datos se llaman árboles.

Asimismo, este capítulo introduce a una estructura

matemática importante que tiene aplicaciones en

ciencias tan diversas como la sociología, química, física, geografía y electrónica. Estas estructuras se denominan grafos.

INTRODUCCIÓN

480 Fundamentos de programación

13.1. INTRODUCCIÓN

Las estructuras de datos que han sido examinadas hasta ahora en este libro son lineales. A cada elemento le correspondía siempre un “siguiente” elemento. La linealidad es típica de cadenas, de elementos de arrays o listas, de campos en registros, entradas en pilas o colas y nodos en listas enlazadas.

En este capítulo se examinarán las estructuras de datos no lineales. En estas estructuras cada elemento puede

tener diferentes “siguientes” elementos, que introduce el concepto de estructuras de bifurcación.

Las estructuras de datos no lineales son árboles y grafos. A estas estructuras se les denomina también estructuras

multienlazadas.

13.2. ÁRBOLES

El árbol es una estructura de datos fundamental en informática, muy utilizada en todos sus campos, porque se adapta a la representación natural de informaciones homogéneas organizadas y de una gran comodidad y rapidez de manipulación. Esta estructura se encuentra en todos los dominios (campos) de la informática, desde la pura algorítmica

(métodos de clasificación y búsqueda...) a la compilación (árboles sintácticos para representar las expresiones o producciones posibles de un lenguaje) o incluso los dominios de la inteligencia artificial (árboles de juegos, árboles de

decisiones, de resolución, etc.).

Las estructuras tipo árbol se usan principalmente para representar datos con una relación jerárquica entre sus

elementos, como son árboles genealógicos, tablas, etc.

Un árbol A es un conjunto finito de uno o más nodos, tales que:

1. Existe un nodo especial denominado RAIZ(v1) del árbol.

2. Los nodos restantes (v2, v3, ..., vn) se dividen en m >= 0 conjuntos disjuntos denominado A1, A2, ..., Am, cada

uno de los cuales es, a su vez, un árbol. Estos árboles se llaman subárboles del RAIZ.

La definición de árbol implica una estructura recursiva. Esto es, la definición del árbol se refiere a otros árboles.

Un árbol con ningún nodo es un árbol nulo; no tiene raíz.

La Figura 13.1 muestra un árbol en el que se ha rotulado cada nodo con una letra dentro de un círculo. Esta es

una notación típica para dibujar árboles.

Los tres subárboles del raíz A son B, C y D, respectivamente. B es la raíz de un árbol con un subárbol E. Este

subárbol no tiene subárbol conectado. El árbol C tiene dos subárboles, F y G.

!

x n

+ log

a b

–

a *

b c

o

< <

a b c d

Figura 13.1. Diferentes árboles.

Estructura de datos no lineales (árboles y grafos) 481

13.2.1. Terminología y representación de un árbol general

La representación y terminología de los árboles se realiza con las típicas notaciones de las relaciones familiares

en los árboles genealógicos: padre, hijo, hermano, ascendente, descendiente, etc. Sea el árbol general de la Figura 13.2.

K L

F G

E

HI J

B C D

A

Figura 13.2. Árbol general.

Las definiciones a tener en cuenta son:

• Raíz del árbol. Todos los árboles que no están vacíos tienen un único nodo raíz. Todos los demás elementos o

nodos se derivan o descienden de él. El nodo raíz no tiene padre, es decir, no es el hijo de ningún elemento.

• Nodo, son los vértices o elementos del árbol.

• Nodo terminal u hoja (leaf node) es aquel nodo que no contiene ningún subárbol (los nodos terminales u hojas

del árbol de la Figura 13.2 son E, F, K, L, H y J).

• A cada nodo que no es hoja se asocia uno o varios subárboles llamados descendientes (offspring) o hijos. De

igual forma, cada nodo tiene asociado un antecesor o ascendiente llamado padre.

• Los nodos de un mismo padre se llaman hermanos.

• Los nodos con uno o dos subárboles —no son hojas ni raíz— se llaman nodos interiores o internos.

• Una colección de dos o más árboles se llama bosque (forest).

• Todos los nodos tienen un solo padre —excepto el raíz— que no tiene padre.

• Se denomina camino el enlace entre dos nodos consecutivos y rama es un camino que termina en una hoja.

• Cada nodo tiene asociado un número de nivel que se determina por la longitud del camino desde el raíz al nodo

específico. Por ejemplo, en el árbol de la Figura 13.2.

Nivel 0 A

Nivel 1 B, C, D

Nivel 2 E, F, G, H, I, J

Nivel 3 K, L

• La altura o profundidad de un árbol es el número máximo de nodos de una rama. Equivale al nivel más alto

de los nodos más uno. El peso de un árbol es el número de nodos terminales. La altura y el peso del árbol de

la Figura 13.2 son 4 y 7, respectivamente.

Las representaciones gráficas de los árboles —además de las ya expuestas— pueden ser las mostradas en la Figura 13.3.

482 Fundamentos de programación

13.3. ÁRBOL BINARIO

Existe un tipo de árbol denominado árbol binario que puede ser implementado fácilmente en una computadora.

Un árbol binario es un conjunto finito de cero o más nodos, tales que:

• Existe un nodo denominado raíz del árbol.

• Cada nodo puede tener 0, 1 o 2 subárboles, conocidos como subárbol izquierdo y subárbol derecho.

La Figura 13.4 representa diferentes tipos de árboles binarios:

B

A

+

C

/

T T1 T2

100

5

5

100

(a) (b) (c)

Figura 13.4. Ejemplos de árboles binarios: (a) expresión árbol a + b/c;

(b) y (c) dos árboles diferentes con valores enteros.

K L

F H G I J

B C D

A

E

A

E

B J I

D H

F

K

L

C G

Figura 13.3 Representaciones de árboles.

Estructura de datos no lineales (árboles y grafos) 483

13.3.1. Terminología de los árboles binarios

Dos árboles binarios se dice que son similares si tienen la misma estructura, y son equivalentes si son similares y

contienen la misma información (Figura 13.5).

Un árbol binario está equilibrado si las alturas de los dos subárboles de cada nodo del árbol se diferencian en una

unidad como máximo.

altura (subárbol izquierdo) – altura (subárbol derecho) ≤ 1

(a)

B

C

F

C

E

(b)

C

Q

X

A

T

G

A

Figura. 13.5. Árboles binarios: (a) similares, (b) equivalentes.

El procesamiento de árboles binarios equilibrados es más sencillo que los árboles no equilibrados. En la Figura 13.6 se muestran dos árboles binarios de diferentes alturas y en la Figura 13.7, árboles equilibrados y sin equilibrar.

T T2

F

(a) (b) (c)

–22

14

/

7

–

T1

E

D

C

B

A

Figura 13.6. Árboles binarios de diferentes alturas: (a) altura 3, (b) árbol vacío, altura 0, (c) altura 6.

484 Fundamentos de programación

(a) (b)

g

j

h

d

i

f

e

b

a

1

2

1

2

3

4

5

1

Figura 13.7. Arboles binarios: (a) equilibrados, (b) no equilibrados.

13.3.2. Árboles binarios completos

Un árbol binario se llama completo si todos sus nodos tienen exactamente dos subárboles, excepto los nodos de los

niveles más bajos que tienen cero. Un árbol binario completo, tal que todos los niveles están llenos, se llama árbol

binario lleno.

En la Figura 13.8 se ilustran ambos tipos de árboles.

Un árbol binario T de nivel h puede tener como máximo 2h – 1 nodos.

La altura de un árbol binario lleno de n nodos es log2(n + 1). A la inversa, el número máximo de nodos de un

árbol binario de altura h será 2h – 1. En la Figura 13.9 se muestra la relación matemática que liga los nodos de

un árbol.

Por último, se denomina árbol degenerado un árbol en el que todos sus nodos tienen solamente un subárbol,

excepto el último.

(a)

L

M

N

I O

J

K

D

E

F

A G

B

C

(b)

E

A

B

C

D

T

H

T

Figura 13.8. (a) árbol binario lleno de altura 4, (b) árbol binario completo de altura 3.

Estructura de datos no lineales (árboles y grafos) 485

D

E

F

A G

B

C

T

Número de nodos (N) = 7 = 2h

– 1

Altura (H) = 3

Nivel 3; número de nodos = 2(3–1) = 4

Figura 13.9. Relaciones matemáticas de un árbol binario.

13.3.3. Conversión de un árbol general en árbol binario

Dado que los árboles binarios es la estructura fundamental en la teoría de árboles, será preciso disponer de algún

mecanismo que permita la conversión de un árbol general en un árbol binario.

Los árboles binarios son más fáciles de programar que los árboles generales. En éstos es imprescindible deducir

cuántas ramas o caminos se desprenden de un nodo en un momento dado. Por ello, y dado que de los árboles binarios

siempre se cuelgan como máximo dos subárboles, su programación será más sencilla.

Afortunadamente existe una técnica para convertir un árbol general a formato de árbol binario. Supongamos que

se tiene el árbol A y se quiere convertir en un árbol binario B. El algoritmo de conversión tiene tres pasos fáciles:

1. La raíz de B es la raíz de A.

2. a) Enlazar al nodo raíz con el camino que conecta el nodo más a la izquierda (su hijo).

b) Enlazar este nodo con los restantes descendientes del nodo raíz en un camino, con lo que se forma el

nivel 1.

c) A continuación, repetir los pasos a) y b) con los nodos del nivel 2, enlazando siempre en un mismo camino todos los hermanos —descendientes del mismo nodo—. Repetir estos pasos hasta llegar al nivel

más alto.

3. Girar el diagrama resultante 45° para diferenciar entre los subárboles izquierdo y derecho.

T

A

B

C

D

E

T

A

C

E

B

D

Figura 13.10. Árboles degenerados.

486 Fundamentos de programación

EJEMPLO 13.1

Convertir el árbol general T en un árbol binario.

K L

F HI J G

B C D

A

E

Siguiendo los pasos del algoritmo.

Paso 1:

K L

F H G I J

B C D

A

E

Paso 2:

A

B

E

C

F D

G

K

L

H

I

J

Estructura de datos no lineales (árboles y grafos) 487

Paso 3:

Obsérvese que no existe camino entre E y F, debido a que no son descendientes del árbol original, ya que ellos tienen

diferentes padres B y C.

En el árbol binario resultante los punteros izquierdos son siempre de un nodo padre a su primer hijo (más a la

izquierda) en el árbol general original. Los punteros derechos son siempre desde un nodo de sus descendientes en el

árbol original.

EJEMPLO 13.2

El algoritmo de conversión puede ser utilizado para convertir un bosque de árboles generales a un solo árbol binario.

El bosque siguiente puede ser representado por un árbol binario.

Bosque de árboles:

F

D

C

B

A

E G

H

I

K

J

L

M N O P

Árbol binario equivalente

A

B

N

O

P

C

D

E

F

H G

K

I

J

L

M

488 Fundamentos de programación

EJEMPLO 13.3

Convertir el árbol general en árbol binario.

d

h i

j

c

a

e g

f

b

Solución

Paso 1:

b

a

Paso 2:

d

h i

j

c

a

e g

f

b

Paso 3:

a

b

e

c

d

g

h

i

J

f

Estructura de datos no lineales (árboles y grafos) 489

13.3.4. Representación de los árboles binarios

Los árboles binarios pueden ser representados de dos modos diferentes:

• Mediante punteros (lenguajes C y C++).

• Mediante arrays o listas enlazadas.

• Vinculando nodos, objetos con mienbros que referencian otros objetos del mismo tipo.

13.3.4.1. Representación por punteros

Cada nodo de un árbol será un registro que contiene al menos tres campos:

• Un campo de datos con un tipo de datos.

• Un puntero al nodo del subárbol izquierdo (que puede ser nulo-null).

• Un puntero al nodo del subárbol derecho (que puede ser nulo-null).

CLAVE

CLAVE CLAVE

NULO

Figura 13.11. Representación de un árbol con punteros.

Ramón

Josefina Andrés

Miguel Laura

Manuel Erika

Ana Pascal

Koldo Clemente

En lenguaje algorítmico se tendrá:

tipo nodo_arbol

puntero_a nodo_arbol: punt

registro : nodo_arbol

490 Fundamentos de programación

<tipo_elemento> : elemento

punt: subiz, subder

fin_registro

13.3.4.2. Representación por listas enlazadas

Mediante una lista enlazada se puede siempre representar el árbol binario de la Figura 13.12.

A

B

D

C

E F

G

Figura 13.12. Árbol binario.

Nodo del árbol: campo 1 INFO (nodo)

campo 2 IZQ (nodo)

campo 3 DER (nodo)

El árbol binario representado como una lista enlazada se representa en la Figura 13.13.

NULO D NULO

B NULO C

A

IZDA INFO DCHA

NULO E NULO F NULO

NULO G NULO

Figura 13.13. Árbol binario como lista enlazada.

13.3.4.3. Representación por arrays

Existen diferentes métodos; uno de los más fáciles es mediante tres arrays lineales paralelos que contemplan el campo de información y los dos punteros de ambos subárboles. Así, por ejemplo, el nodo raíz RAMÓN tendrá dos punteros

Estructura de datos no lineales (árboles y grafos) 491

IZQ:(9) —JOSEFINA— y DER:(16) —ANDRÉS—, mientras que el nodo CLEMENTE, al no tener descendientes, sus

punteros se consideran cero (IZQ:0, DER:0).

3 Ramón

9 Josefina Andrés

6 Miguel 7 Laura

12 Manuel 11 Erika

15 Ana 4 Pascal

16

8 Koldo 13 Clemente

16

15

14

13

12

11

10

9

8

7

6

5

4

2

1

ANDRÉS

ANA

CLEMENTE

MANUEL

ERIKA

JOSEFINA

KOLDO

LAURA

MIGUEL

PASCAL

RAMÓN

INFO

3

P

IZQ. DER.

9

15

8

0

0

0

6

0

11

12

0

16

4

0

0

0

0

7

0

0

0

13

Figura 13.14. Árbol binario como arrays.

Otro método resulta más sencillo —un array lineal—. Para ello se selecciona un array lineal ARBOL.

50

21

12

75

32 90

16 25 85

492 Fundamentos de programación

El algoritmo de transformación es:

1. La raíz del árbol se guarda en ARBOL [1].

2. si un nodo n está en ARBOL[i] entonces

su hijo izquierdo se pone en ARBOL[2*i]

y su hijo derecho en ARBOL[2*i + 1]

si un subárbol está vacío, se le da el valor NULO.

Este sistema requiere más posiciones de memoria que nodos tiene el árbol. Así, la transformación necesitará un

array con 2h + 2 elementos si el árbol tiene una profundidad h. En nuestro caso, como la profundidad es 3, requerirá

32 posiciones (25

), aunque si no se incluyen las entradas nulas de los nodos terminales, veremos cómo sólo necesita

catorce posiciones.

Árbol

1

.

.

.

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

50

21

75

12

32

0

90

0

16

25

85

Estructura de datos no lineales (árboles y grafos) 493

Un tercer método, muy similar al primero, sería la representación mediante un array de registros.

ANDRÉS

ANA

CLEMENTE

MANUEL

ERIKA

JOSEFINA

KOLDO

LAURA

MIGUEL

PASCAL

RAMÓN

INFO IZQ DER

9

0

12

11

0

6

0

0

0

8

15

16

13

0

0

0

7

0

0

0

0

4

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

P 3

13.3.5. Recorrido de un árbol binario

Se denomina recorrido de un árbol el proceso que permite acceder una sola vez a cada uno de los nodos del árbol.

Cuando un árbol se recorre, el conjunto completo de nodos se examina.

Existen muchos modos para recorrer un árbol binario. Por ejemplo, existen seis diferentes recorridos generales

en profundidad de un árbol binario, simétricos dos a dos.

Los algoritmos de recorrido de un árbol binario presentan tres tipos de actividades comunes:

• Visitar el nodo raíz.

• Recorrer el subárbol izquierdo.

• Recorrer el subárbol derecho.

Estas tres acciones repartidas en diferentes órdenes proporcionan los diferentes recorridos del árbol en profundidad. Los más frecuentes tienen siempre en común recorrer primero el subárbol izquierdo y luego el subárbol derecho.

Los algoritmos que lo realizan llaman pre-orden, post-orden, in-orden y su nombre refleja el momento en que se

visita el nodo raíz. En el in-orden el raíz está en el medio del recorrido, en el pre-orden el raíz está el primero y en

el post-orden el raíz está el último:

Recorrido pre-orden

1. Visitar el raíz.

2. Recorrer el subárbol izquierdo en pre-orden.

3. Recorrer el subárbol derecho en pre-orden.

Recorrido in-orden

1. Recorrer el subárbol izquierdo en in-orden.

2. Visitar el raíz.

3. Recorrer el subárbol derecho en in-orden.

494 Fundamentos de programación

Recorrido post-orden

1. Recorrer el subárbol izquierdo en post-orden.

2. Recorrer el subárbol derecho en post-orden.

3. Visitar el raíz.

Obsérvese que todas estas definiciones tienen naturaleza recursiva.

En la Figura 13.15 se muestran los recorridos de diferentes árboles binarios.

Árbol 1: c * d + e

c

*

+

d

e g

e

↑

f

+

c

/

d

/

a b

*

+

Árbol 2: [((a + b) * c/d) + e ^ f]/g

T Z

M

E

B L

A D

N

P

V

Árbol 3

Figura 13.15. Recorrido de árboles binarios.

Árbol 1 Pre-orden + * c d e

In-orden c * d + e

Post-orden c d * e +

Árbol 2 Pre-orden / + * + a b / c d ^ e f g

In-orden a + b * c / d + e ^ f / g

Post-orden a b + c d / * e f ^ + g /

Árbol 3 Pre-orden MEBADLPNVTZ

In-orden ABDELMNPTVZ

Post-orden ADBLENTZVPM

EJEMPLO 13.4

Calcular los recorridos del árbol binario.

*

(/)

(–)

c d

e

+

a b

Solución

recorrido pre-orden / * + ab - cde

recorrido in-orden a + b * c - d/e

recorrido post-orden ab + cd - * e/

Estructura de datos no lineales (árboles y grafos) 495

EJEMPLO 13.5

Realizar los recorridos del árbol binario.

2

5

1

8

4 10

7 12

Solución

recorrido pre-orden 2 5 1 7 4 8 10 12

recorrido in-orden 1 7 5 4 2 8 12 10

recorrido post-orden 7 1 4 5 12 10 8 2

13.4. ÁRBOL BINARIO DE BÚSQUEDA

Recordará del Capítulo 10, “Ordenación, búsqueda e intercalación”, que para localizar un elemento en un array se

podía realizar una búsqueda lineal; sin embargo, si el array era grande, una búsqueda lineal era ineficaz por su lentitud, especialmente si el elemento no estaba en el array, ya que requería la lectura completa del array. Se ganaba

tiempo si se clasificaba el array y se utilizaba una búsqueda binaria. Sin embargo, en un proceso de arrays las inserciones y eliminaciones son continuas, por lo que esto se hará complejo en cualquier método.

En los casos de gran número de operaciones sobre arrays o listas, lo que se necesita es una estructura donde los

elementos puedan ser eficazmente localizados, insertados o borrados. Una solución a este problema es una variante del árbol binario que se conoce como árbol binario de búsqueda o árbol binario clasificado (binary search

tree).

El árbol binario de búsqueda se construirá teniendo en cuenta las siguientes premisas:

• El primer elemento se utiliza para crear el nodo raíz.

• Los valores del árbol deben ser tales que pueda existir un orden (entero, real, lógico o carácter e incluso definido por el usuario si implica un orden).

• En cualquier nodo todos los valores del subárbol izquierdo del nodo son menor o igual al valor del nodo. De

modo similar, todos los valores del subárbol derecho deben ser mayores que los valores del nodo.

Si estas condiciones se mantienen, es sencillo probar que el recorrido in-orden del árbol produce los valores

clasificados por orden. Así, por ejemplo, en la Figura 13.16 se muestra un árbol binario.

Los tres recorridos del árbol son:

pre-orden P F B H G S R Y T W Z

in-orden B F G H P R S T Y W Z

post-orden B G H F R T W Z Y S P

En esencia, un árbol binario contiene una clave en cada nodo que satisface las tres condiciones anteriores.

Un árbol con las propiedades anteriores se denomina árbol binario de búsqueda.

496 Fundamentos de programación

P

F

B

S

H Y

G T

H

W

T

Figura 13.16. Árbol binario.

EJEMPLO 13.6

Se dispone de un array que contiene los siguientes caracteres:

D F E B A C G

Construir un árbol binario de búsqueda.

Los pasos para la construcción del algoritmo son:

1. Nodo raíz del árbol: D.

2. El siguiente elemento se convierte en el descendente derecho, dado que F alfabéticamente es mayor que D.

3. A continuación, se compara E con el raíz. Dado que E es mayor que D, pasará a ser un hijo de F y como

E < F será el hijo izquierdo.

4. El siguiente elemento B se compara con el raíz D y como B < D y es el primer elemento que cumple esta

condición, B será el hijo izquierdo de D.

5. Se repiten los pasos hasta el último elemento.

El árbol binario de búsqueda resultante sería:

D

B

A C

F

E G

EJEMPLO 13.7

Construir el árbol binario de búsqueda correspondiente a la lista de números.

4 19 -7 49 100 0 22 12

Estructura de datos no lineales (árboles y grafos) 497

El primer valor, como ya se ha comentado, es la raíz del árbol: es decir, 4. El siguiente valor, 19, se compara con

4; como es más grande se lleva al subárbol derecho de 4. El siguiente valor, –7, se compara con el raíz y es menor

que su valor, 4; por tanto, se mueve al subárbol izquierdo. La Figura 13.17 muestra los sucesivos pasos.

4

–7 19

0 49

22

12

100

Figura 13.17. Construcción de un árbol binario.

13.4.1. Búsqueda de un elemento

La búsqueda en un árbol binario ordenado es dicotómica, ya que a cada examen de un nodo se elimina aquel de los

subárboles que no contiene el valor buscado (valores todos inferiores o todos superiores).

45

50

52

9

10

11

12

5

7

13

48

El algoritmo de búsqueda del elemento —clave x— se realiza comparándolo con la clave del raíz del árbol. Si

no es el mismo, se pasa al subárbol izquierdo o derecho, según el resultado de la comparación, y se repite la búsqueda en ese subárbol. La terminación del procedimiento se producirá cuando:

• Se encuentra la clave.

• No se encuentra la clave; se continúa hasta encontrar un subárbol vacío.

procedimiento buscar (E punt: RAIZ;

E <tipo_elemento>: elemento;

S punt: actual, anterior)

var

logico: encontrado

inicio

encontrado ← falso

anterior ← nulo

actual ← raiz

mientras no encontrado Y (actual<>nulo) hacer

si actual→.elemento = elemento entonces

498 Fundamentos de programación

encontrado ← verdad

si_no

anterior ← actual

si actual→.elemento > elemento entonces

actual ← actual→.izdo

si_no

actual ← actual→.dcho

fin_si

fin_si

fin_mientras

si no encontrado entonces

escribir('no existe', elemento)

si_no

escribir( elemento, 'existe')

fin_si

fin_procedimiento

//< tipo_elemento> en este algoritmo es un tipo de dato simple

13.4.2. Insertar un elemento

Para insertar un elemento en el árbol A se ha de comprobar, en primer lugar, que el elemento no se encuentra en el

árbol, ya que su caso no precisa ser insertado. Si el elemento no existe, la inserción se realiza en un nodo en el que

al menos uno de los dos punteros izq o der tenga valor nulo.

Para realizar la condición anterior se desciende en el árbol a partir del nodo raíz, dirigiéndose de izquierda a derecha de un nodo, según que el valor a insertar sea inferior o superior al valor del campo clave INFO de este nodo.

Cuando se alcanza un nodo del árbol en que no se puede continuar, el nuevo elemento se engancha a la izquierda o

derecha de este nodo en función de que su valor sea inferior o superior al del nodo alcanzado.

El algoritmo de inserción del elemento x es:

procedimiento insertar (E/S punt: raiz;

E <tipo_elemento> : elemento)

var

punt : nuevo,

actual,

anterior

inicio

buscar (raiz, elemento, actual, anterior)

si actual<> NULO entonces

escribir ('elemento duplicado')

si_no

reservar (nuevo)

nuevo→.elemento ← elemento

nuevo→.izdo ← nulo

nuevo→.dcho ← nulo

si anterior = nulo entonces

raiz ← nuevo

si_no

si anterior→.elemento > elemento entonces

anterior→.izdo ← nuevo

si_no

anterior→.dcho ← nuevo

fin_si

fin_si

fin_si

fin_procedimiento

// <tipo_elemento> es un tipo simple

Estructura de datos no lineales (árboles y grafos) 499

–7

4

49

T

(a)

100

19 –7

49

T

(b)

100

19

(c)

19

0

22

49

100

12

4

0

T

4

–7

Figura 13.18. Inserciones en un árbol de búsqueda binaria: (a) insertar 100, (b) insertar (0), (c) insertar 22 y 12.

Para insertar el valor x en el árbol binario ordenado se necesitará llamar al subprograma insertar.

13.4.3. Eliminación de un elemento

La eliminación de un elemento debe conservar el orden de los elementos del árbol. Se consideran diferentes casos,

según la posición del elemento o nodo en el árbol:

• Si el elemento es una hoja, se suprime simplemente.

• Si el elemento no tiene más que un descendiente, se sustituye entonces por ese descendiente.

• Si el elemento tiene dos descendientes, se sustituye por el elemento inmediato inferior situado lo más a la derecha posible de su subárbol izquierdo.

Para poder realizar estas acciones será preciso conocer la siguiente información del nodo a eliminar:

• Conocer su posición en el árbol.

• Conocer la dirección de su padre.

• Conocer si el nodo a eliminar tiene hijos, si son 1 o 2 hijos, y en el caso de que sólo sea uno, si es hijo derecho

o izquierdo.

La Figura 13.19 muestra los tres posibles casos de eliminación de un nodo: (a) eliminar C, (b) eliminar F, (c)

eliminar B.

(a)

T

A \\

B

(b)

T

A F

B

C E

D

(c)

T

E

D

A C

B

C

Figura 13.19. Casos posibles de eliminación de un nodo.

500 Fundamentos de programación

En la Figura 13.20 se muestra el caso de eliminación de un nodo con un subárbol en un gráfico comparativo

antes y después de la eliminación.

(a)

19

4

–7

49

100

T

N

(b)

19

4

–7

100

T

Figura 13.20. Eliminación de un nodo con un subárbol.

En la Figura 13.21 se muestra el caso de la eliminación de un nodo (27) que tiene dos subárboles no nulos. En

este caso se busca el nodo sucesor cuyo campo de información le siga en orden ascendente, es decir, 42, se intercambia entonces con el elemento que se desea borrar, 27.

(a)

27

4

–7

22

12

49

100

T

N

42

(b)

42

4

–9

–7

22

12

49

100

T

–9

Figura 13.21. Eliminación de un nodo con dos subárboles no nulos.

EJEMPLO 13.8

Deducir los árboles resultantes de eliminar el elemento 3 en el árbol A y el elemento 7 en el árbol B.

Árbol A

9

10

11

19

3

4

5

6

2

8

17

9

10

11

19

4

5

6

2

8

17

Estructura de datos no lineales (árboles y grafos) 501

Árbol B. En este caso se busca el nodo sucesor cuyo campo de información le siga en orden decreciente, es decir, 6.

18

24

7

8

9

10

16

2

4

6

18

24

6

8

9

10

16

2

4

Árbol binario mediante arrays

Los árboles deben ser tratados como estructuras dinámicas. No obstante, si el lenguaje no tiene punteros podremos

simularlos mediante arrays.

ELEMENTO IZQ DER

N.o

X X X X N.o N. o

RAÍZ

N.o

VACÍO

Izdo y dcho serán dos campos numéricos para indicar la posición en que están los hijos izquierdo y derecho. El

valor 0 indicaría que no tiene hijo.

Trataremos el array como una lista ENLAZADA y necesitaremos una LISTA DE VACIOS y una variable VACIO

que apunte al primer elemento de la lista de vacíos. Para almacenar la lista de vacíos es indiferente que utilicemos el

campo Izdo o Dcho.

EJEMPLO 13.9

algoritmo arbol_binario_mediante_arrays

const

Max = <expresion>

tipo

registro: TipoElemento

... : ...

... : ...

fin_registro

registro: TipoNodo

TipoElemento : Elemento

Entero : Izdo, Dcho

fin_registro

array[1..Max] de TipoNodo : Arr

var

Arr : a

502 Fundamentos de programación

Entero : opcion

TipoElemento : elemento

Entero : raiz

Entero : vacio

inicio

iniciar(a,raiz,vacio)

repetir

menu

escribir ('OPCIÓN: ')

repetir

leer (opcion)

hasta_que (opcion >= 0) Y (opcion <= 3)

según_sea opcion hacer

1 :

listado (a,raiz)

escribir ('INTRODUZCA NUEVO ELEMENTO: ')

proc_leer (elemento)

altas (a, elemento, raiz, vacio)

listado (a,raiz)

pausa

2 :

listado (a,raiz)

escribir ('INTRODUZCA ELEMENTO A DAR DE BAJA: ')

proc_leer (elemento)

bajas (a, elemento, raiz, vacio)

listado (a,raiz)

pausa

3:

listado (a,raiz)

pausa

fin_según

hasta_que opcion = 0

fin

procedimiento pausa

var

cadena : c

inicio

escribir('PULSE RETURN PARA CONTINUAR')

leer(c)

fin_procedimiento

procedimiento menu

inicio

escribir ('1.- ALTAS')

escribir ('2.- BAJAS')

escribir ('3.- LISTADO')

escribir ('0.- FIN')

fin_procedimiento

procedimiento iniciar(S Arr: a; S Entero: raiz, vacio)

var

Entero: i

inicio

raiz ← 0

Estructura de datos no lineales (árboles y grafos) 503

vacio ← 1

desde i ← 1 hasta Max-1 hacer

a[i].dcho ← i+1

fin_desde

a[Max].dcho ← 0

fin_procedimiento

logico función ArbolVacio(E Entero: raiz)

inicio

si raiz=0 entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

logico funcion ArbolLleno(E Entero: vacio)

inicio

si vacio=0 entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

procedimiento inorden(E/S Arr: a; E Entero: raiz)

inicio

si raiz <> 0 entonces

inorden(a,a[raiz].Izdo)

proc_escribir(a[raiz].elemento)

inorden(a,a[raiz].Dcho)

fin_si

fin_procedimiento

procedimiento preorden(E/S Arr: a; E Entero: raiz)

inicio

si raiz <> 0 entonces

proc_escribir(a[raiz].elemento)

preorden(a,a[raiz].Izdo)

preorden(a,a[raiz].Dcho)

fin_si

fin_procedimiento

procedimiento postorden(E/S Arr: a; E Entero: raiz)

inicio

si raiz <> 0 entonces

postorden(a,a[raiz].Izdo)

postorden(a,a[raiz].Dcho)

proc_escribir(a[raiz].elemento)

fin_si

fin_procedimiento

procedimiento buscar(E/S Arr: a; E entero: raiz;

E TipoElemento: elemento;

S entero: act, ant)

var

logico: encontrado

504 Fundamentos de programación

inicio

encontrado ← falso

act ← raiz

ant ← 0

mientras no encontrado y (act<>0) hacer

si igual(elemento, a[act].elemento) entonces

encontrado ← verdad

si_no

ant ← act

si mayor(a[act].elemento, elemento) entonces

act ← a[act].Izdo

si_no

act ← a[act].Dcho

fin_si

fin_si

fin_mientras

fin_procedimiento

procedimiento altas(E/S Arr: A; E TipoElemento: elemento;

E/S entero: raiz, vacio)

var

entero: act,ant,auxi

inicio

si vacio <> 0 entonces

buscar(a, raiz, elemento, act, ant)

si act <> 0 entonces

escribir('ESE ELEMENTO YA EXISTE')

si_no

auxi ← vacio

vacio ← a[auxi].Dcho

a[auxi].elemento ← elemento

a[auxi].Izdo ← 0

a[auxi].Dcho ← 0

si ant = 0 entonces

raiz ← auxi

si_no

si mayor(a[ant].elemento, elemento) entonces

a[ant].Izdo ← auxi

si_no

a[ant].Dcho ← auxi

fin_si

fin_si

fin_si

fin_si

fin_procedimiento

procedimiento bajas(E/S Arr: A; E TipoElemento: elemento;

E/S entero: raiz, vacio)

var

entero: act, ant, auxi

inicio

buscar(a, raiz, elemento, act, ant)

si act = 0 entonces

escribir('ESE ELEMENTO NO EXISTE')

si_no

si (a[act].Izdo = 0) Y (a[act].Dcho = 0) entonces

Estructura de datos no lineales (árboles y grafos) 505

si ant = 0 entonces

raiz ← 0

si_no

si a[ant].Izdo = act entonces

a[ant].Izdo ← 0

si_no

a[ant].Dcho ← 0

fin_si

fin_si

si_no

si (a[act].Izdo <> 0) Y (a[act].Dcho <> 0) entonces

ant ← act

auxi ← a[act].Izdo

mientras a[auxi].Dcho <> 0 hacer

ant ← auxi

auxi ← a[auxi].Dcho

fin_mientras

a[act].Elemento ← a[auxi].Elemento

si ant = act entonces

a[ant].Izdo ← a[auxi].Izdo

si_no

a[ant].Dcho ← a[auxi].Izdo

fin_si

act ← auxi

si_no

si a[act].Dcho <> 0 entonces

si ant = 0 entonces

raíz ← a[act].Dcho

si_no

si a[ant].Izdo = act entonces

a[ant].Izdo ← a[act].Dcho

si_no

a[ant].Dcho ← a[act].Dcho

fin_si

fin_si

si_no

si ant = 0 entonces

raíz ← a[act].Izdo

si_no

si a[ant].Dcho = act entonces

a[ant].Dcho ← a[act].Izdo

si_no

a[ant].Izdo ← a[act].Izdo

fin_si

fin_si

fin_si

fin_si

fin_si

a[act].Dcho ← vacio

vacio ← act

fin_si

fin_procedimiento

procedimiento listado (E Arr: a; E Entero: raiz)

inicio

escribir ('INORDEN: ')

506 Fundamentos de programación

inorden (a, raiz)

escribir ('PREORDEN: ')

preorden (a, raiz)

escribir ('POSTORDEN: ')

postorden (a, raiz)

fin_procedimiento

ELEMENTO DCHO

0

RAÍZ

VACÍO

2

3

4

5

6

7

0

1

Array

3

0

0

5

6

7

0

2

0

0

elemento 1

elemento 2

elemento 3

VACÍO

1 4

RAÍZ

3

4

0

5

6

7

0

0

0

0

elemento 1

elemento 2

elemento 3

VACÍO

1 2

RAÍZ

Iniciar Iniciar

13.5. GRAFOS

Los grafos son otra estructura de datos no lineal y que tiene gran número de aplicaciones. El estudio del análisis de

grafos ha interesado a los matemáticos durante siglos y representa una parte importante de la teoría combinatoria en

matemáticas. Aunque la teoría de grafos es compleja y amplia, en esta sección se realizará una introducción a la

teoría de grafos y a los algoritmos que permiten su solución por computadora.

Los árboles binarios representan estructuras jerárquicas con limitaciones de dos subárboles por cada nodo. Si se

eliminan las restricciones de que cada nodo puede apuntar a dos nodos —como máximo— y que cada nodo puede

estar apuntado por otro nodo —como máximo— nos encontramos con un grafo.

Ejemplos de grafos en la vida real los tenemos en la red de carreteras de un estado o región, la red de enlaces

ferroviarios o aéreos nacionales, etc.

En una red de carreteras los nudos de la red representan los vértices del grafo y las carreteras de unión de dos

ciudades los arcos, de modo que a cada arco se asocia una información tal como la distancia, el consumo en gasolina por automóvil, etc.

Los grafos nos pueden ayudar a resolver problemas como éste. Supóngase que ciertas carreteras del norte del

Estado han sido bloqueadas por una reciente tormenta de nieve. ¿Cómo se puede saber si todas las ciudades de ese

Estado se pueden alcanzar por carretera desde la capital o si existen ciudades aisladas? Evidentemente existe la solución del estudio de un mapa de carreteras; sin embargo, si existen muchas ciudades, la obtención de la solución

puede ser ardua y costosa en tiempo. Una computadora y un algoritmo adecuado de grafos solucionarán fácilmente

el problema.

13.5.1. Terminología de grafos

Formalmente un grafo es un conjunto de puntos —una estructura de datos— y un conjunto de líneas, cada una de

las cuales une un punto a otro. Los puntos se llaman nodos o vértices del grafo y las líneas se llaman aristas o arcos

(edges).

Se representan el conjunto de vértices de un grafo dado G por VG y el conjunto de arcos por AG. Por ejemplo, en

el grafo G de la Figura 13.23:

VG = {a, b, c, d}

AG = {1, 2, 3, 4, 5, 6, 7, 8}

Estructura de datos no lineales (árboles y grafos) 507

PARÍS

NANCY

MARSELLA TOULOUSE

BURDEOS

NANTES

LYON

386

491

468 557

562

383

338

224

485

393

314

Figura 13.22. Grafo de una red de carreteras.

b

1

a 8 7

6

5

3

2

c

4

d

Figura 13.23. Grafo G.

El número de elementos de VG se llama orden del grafo. Un grafo nulo es un grafo de orden cero.

Una arista se representa por los vértices que conecta. La arista 3 conecta los vértices b y c, y se representa por

V(b, c). Algunos vértices pueden conectar un nodo consigo mismo; por ejemplo, la arista 8 tiene el formato V(a, a).

Estas aristas se denominan bucles o lazos.

Un grafo G se denomina sencillo si se cumplen las siguientes condiciones:

• No tiene lazos, no existe un arco en AG de la forma (V, V).

• No existe más que un arco para unir dos nodos, es decir, no existe más que un arco (V1, V2) para cualquier par

de vértices V1, V2.

En la Figura 13.24 se representa un grafo sencillo.

b

1

a

3

2

4 c

d

Figura 13.24. Grafo sencillo.

Un grafo que no es sencillo se denomina grafo múltiple.

Un camino es una secuencia de uno o más arcos que conectan dos nodos. Representaremos por C(Vi

, Vj

) un camino que conecta los vértices Vi

y Vj

.

508 Fundamentos de programación

La longitud de un camino es el número de arcos que comprende. En el grafo de la Figura 13.24 existen los siguientes caminos entre los nodos b y d.

C(b,d) = (b,c) (c,d) longitud = 2

C(b,d) = (b,c) (c,b) (b,c) (c,d) longitud = 4

C(b,d) = (b,d) longitud = 1

C(b,d) = (b,d) (c,b) (b,d) longitud = 3

Dos vértices se dice que son adyacentes (inmediatos) si hay un arco que los une. Así, Vi

y Vj

son adyacentes si

existe un camino que los une. Esta definición es muy general y normalmente se particulariza; si existe un camino

desde A a B, decimos que A es adyacente a B y B es adyacente desde A. Así, en el grafo de la Figura 13.25, Las

Vegas es adyacente a Nueva York, pero Nueva York no es adyacente a Las Vegas.

Se consideran dos tipos de grafos:

Dirigidos los vértices apuntan unos a otros; los arcos están dirigidos o tienen dirección.

No-dirigidos los vértices están relacionados, pero no se apuntan unos a otros; la dirección no es importante.

En la Figura 13.25 el grafo es dirigido, dado que la dirección es importante; así, existe un vuelo entre Las Vegas

y Nueva York, pero no en sentido contrario.

grafo conectado existe siempre un camino que une dos vértices cualesquiera,

grafo desconectado existen vértices que no están unidos por un camino.

1

3

2

4 5

6

1

3

2

4 5

6

(a) no dirigido (b) dirigido

Figura 13.25. Grafo: (a) no dirigido, (b) dirigido.

F

A

H J

G

(a) conectado

A

C

F

E

G

(b) conectado (b) no conectado

B

C

D

I

E

B

D

H

A

C

E F

G

B

D

H

J

L

I

K

Figura 13.26. Grafos conectados y no conectados.

Otros tipos de grafos de gran interés se muestran en la Figura 13.27. Un grafo completo es aquel en que cada

vértice está conectado con todos y cada uno de los restantes nodos. Si existen n vértices, habrá n(n – 1) arcos en un

grafo completo y dirigido, y n(n – 1)/2 aristas en un grafo no dirigido completo.

A B

C D

(a) grafo completo dirigido

J

K N

L M

(b) grafo completo no dirigido

Figura 13.27. Grafos completos.

Estructura de datos no lineales (árboles y grafos) 509

Un grafo ponderado o con peso es aquel en el que cada arista o arco tiene un valor. Los grafos con peso suelen

ser muy importantes, ya que pueden representar situaciones de gran interés; por ejemplo, los vértices pueden ser

ciudades y las aristas distancias o precios del pasaje de ferrocarril o avión entre ambas ciudades. Eso nos puede permitir calcular cuál es el recorrido más económico entre dos ciudades, sumando los importes de los billetes de las

ciudades existentes en el camino y así poder tomar una decisión acertada respecto al viaje e incluso estudiar el posible cambio de medio de transporte: avión o automóvil, si éstos resultan más baratos.

La solución de encontrar el camino más corto, el de menor precio o más económico entre dos vértices de un

grafo, es un algoritmo importante en la teoría de grafos. (El algoritmo de Dijkstra es un algoritmo tipo para la solución de dichos problemas.)

13.5.2. Representación de grafos

Existen dos técnicas estándar para representar un grafo G: la matriz de adyacencia (mediante arrays) y la lista de

adyacencia (mediante punteros/listas enlazadas).

13.5.2.1. Matriz de adyacencia

La matriz de adyacencia M es un array de dos dimensiones que representa las conexiones entre pares de vértices. Sea

un grafo G con un conjunto de nodos VG y un conjunto de aristas AG. Supongamos que el grafo es de orden N, donde

N >= 1. La matriz de adyacencia M se representa por una matriz de N × N elementos, donde:

M(i, j) = { 1 si existe un arco (Vi

, Vj

) en AG, Vi

es adyacente a Vj

0, en caso contrario

Las columnas y las filas de la matriz representan los vértices del grafo. Si existe una arista desde i a j (esto es, el

vértice i es adyacente a j), se introduce un 1; si no existe la arista, se introduce un 0; lógicamente, los elementos de

la diagonal principal son todos ceros, ya que el coste de la arista i a i es 0.

Si G es un grafo no dirigido, la matriz es simétrica M(i, j) = M(j, i). La matriz de adyacencia del grafo de la Figura 13.25 se indica en la Figura 13.28.

j

i 123456

10 1 0 0 0 0

21 0 1 0 0 0

30 1 0 1 1 1

40 0 1 0 0 0

50 0 1 0 0 0

60 0 1 0 0 0

Figura 13.28. Matriz de adyacencia.

Si el grafo fuese dirigido, su matriz resultante sería:

j

i 123456

10 1 0 0 0 0

20 0 1 0 0 0

30 0 0 0 1 1

40 0 1 0 0 0

50 0 0 0 0 0

60 0 0 0 0 0

510 Fundamentos de programación

EJEMPLO 13.10

Deducir la matriz de adyacencia del grafo siguiente:

La matriz de adyacencia resultante de este grafo, cuyos vértices representan ciudades y los pesos de las aristas,

los precios de pasajes de avión en dólares es

Solución

3000 3000

390

2000

2000

1000

1500

1000

3500

LA LV

SF

NY

KC

SF LA LV KC NY

SF 1000

LA 1000 390 2000

LV 390 3000 2500

KC 2000 3000

NY 1500 350

EJEMPLO 13.11

Sea un grafo con aristas ponderadas. Los vértices representan ciudades y las aristas las rutas utilizadas por los camiones de una empresa de transporte de mercancías. Cada arista está rotulada con la distancia entre las parejas de

ciudades enlazadas directamente. En este caso utilizaremos una matriz triangular, ya que la matriz es simétrica.

Nota

Obsérvese como consecuencia de este ejemplo que las aristas ponderadas tienen una gran aplicación.

• En transporte comúnmente representan distancias, precios de billetes, tiempos.

• En hidráulica, capacidades. Por ejemplo, el caudal de un oleoducto entre diferentes ciudades litros/segundo.

13.5.2.2. Lista de adyacencia

El segundo método utilizado para representar grafos es útil cuando un grafo tiene muchos vértices y pocas aristas;

es la lista de adyacencia. En esta representación se utiliza una lista enlazada por cada vértice v del grafo que tenga

vértices adyacentes desde él.

El grafo completo incluye dos partes: un directorio y un conjunto de listas enlazadas. Hay una entrada en el directorio por cada nodo del grafo. La entrada en el directorio del nodo i apunta a una lista enlazada que representa los

nodos que son conectados al nodo i. Cada registro de la lista enlazada tiene dos campos: uno es un identificador de

nodo, otro es un enlace al siguiente elemento de la lista; la lista enlazada representa arcos.

Una lista de adyacencia del grafo de la Figura 13.25a se da en la Figura 13.29.

6 NULO

3

5

2 NULO

4

2 NULO

1

2

3

3

3

NULO

NULO

NULO

1

2

3

4

5

6

DIRECTORIO

Figura 13.29. Lista de adyacencia.

Estructura de datos no lineales (árboles y grafos) 511

Un grafo no dirigido de orden N con A arcos requiere N entradas en el directorio y 2*A entradas de listas enlazadas, excepto si existen bucles que reducen el número de listas enlazadas en 1.

Un grafo dirigido de orden N con A arcos requiere N entradas en el directorio y A entradas de listas enlazadas.

3

6

2 NULO

2

5

3 NULO

1

2

3

4

5

6

NULO

NULO

NULO

NULO

DIRECTORIO

Figura 13.30.

EJEMPLO 13.12

La lista de adyacencia del grafo del Ejemplo 13.10 es

SF

LA

LV

KC

NY

LA 1000

SF 1000

LA 390

LA 2000

SF 1500

LV 390

KC 3000

LV 3000

KC 3500

KC 2000

NY 2500

La elección de la representación depende del algoritmo particular que se vaya a implementar y si el grafo es

“disperso” o “denso”. Un grafo disperso es uno en el que el número de vértices N es mucho mayor que el número

de arcos. En un grafo denso el número de arcos se acerca al máximo.

512 Fundamentos de programación

ACTIVIDADES DE PROGRAMACIÓN RESUELTAS

13.1. Deducir las fórmulas de las expresiones representadas por los siguientes árboles de expresión.

!

x n

+ log

a b

–

a *

b c

o

< <

a b c d

a)

d)

b) c)

e)

a) a + b

b) log x

c) n!

d) a – (b * c)

e) (a < b) o (c < d)

13.2. Deducir la fórmula que representa el siguiente árbol expresión.

– /

1 2

+

– ^

←

X /

*

2 a

b

^ *

b 2 * c

4 a

x = (–b + (b2

– 4 * a * c)

(1/2)) / (2 * a)

es decir, una de las raíces solución de la ecuación cuadrática o de segundo grado:

ax2

+ bx + c = 0.

13.3. Teniendo en cuenta que nuestro lenguaje de programación no maneja estructuras dinámicas de datos, escribir un

procedimiento que inserte un nuevo nodo en un árbol binario en el lugar correspondiente según su valor. Escribir

otro procedimiento que permita conocer el número de nodos de un árbol binario. Utilizar ambos procedimientos

desde un algoritmo que cree el árbol y nos informe sobre su número de nodos.

Estructura de datos no lineales (árboles y grafos) 513

Análisis del problema

El procedimiento de inserción será análogo al de altas que aparece en al ejercicio 13.9. Para conocer el número de nodos

del árbol se realiza su recorrido, por uno cualquiera de los métodos ya comentados —inorden, preorden, postorden— y se

irán contando.

El programa principal comenzará con un proceso de inicialización, a continuación utilizará una estructura repetitiva

que permita la inserción de un número indeterminado de nodos en el árbol y, por último, llamará al procedimiento para

contarlos.

Al no especificarse en el enunciado el tipo de información que se almacena en los registros del árbol, ésta se tratará de

forma genérica, recurriendo a procedimientos y funciones auxiliares no desarrollados que permitan manipularla, como, por

ejemplo, leerelemento(elemento), escribirelemento(elemento), distinto(elemento,'0').

Diseño del algoritmo

algoritmo ejercicio_13_3

const

Máx = ...

tipo

registro: tipoelemento

... : ...

... : ...

fin_registro

registro: tiponodo

tipoelemento : elemento

entero : izdo, dcho

fin_registro

array[1..Máx] de tiponodo: arr

var

arr : a

tipoelemento : elemento

entero : raíz, vacío

inicio

iniciar(a,raíz,vacío)

escribir ('Introduzca nuevo elemento: ')

si no árbollleno(vacío) entonces

leerelemento (elemento)

fin_si

mientras distinto(elemento,'0') y no árbollleno(vacío) hacer

altas (a, elemento, raíz, vacío)

si no árbollleno(vacío) entonces

escribir ('Introduzca nuevo elemento: ')

leerelemento (elemento)

fin_si

fin_mientras

listado (a, raíz)

fin

procedimiento iniciar(S arr: a ; S entero: raíz, vacío)

var

entero: i

inicio

raíz ← 0

vacío ← 1

desde i ← 1 hasta Máx-1 hacer

a[i].dcho ← i+1

fin_desde

a[Máx].dcho ← 0

fin_procedimiento

514 Fundamentos de programación

lógico función árbollleno(E entero: vacío)

inicio

si vacío = 0 entonces

devolver(verdad)

si_no

devolver(falso)

fin_si

fin_función

procedimiento inorden(E arr: a; E entero: raíz; E/S entero: cont)

inicio

si raíz <> 0 entonces

inorden(a, a[raíz].izdo, cont)

cont ← cont + 1

escribirelemento(a[raíz].elemento)

// Además de contar los nodos visualiza la

// información almacenada en ellos

inorden(a, a[raíz].dcho, cont)

fin_si

fin_procedimiento

procedimiento buscar(E arr: a ; E tipoelemento:elemento;

S entero: act, ant)

var

lógico: encontrado

inicio

encontrado ← falso

act ← raíz

ant ← 0

mientras no encontrado y (act <> 0) hacer

si igual(elemento, a[act].elemento) entonces

encontrado ← verdad

si_no

ant ← act

si mayor(a[act].elemento, elemento) entonces

act ← a[act].izdo

si_no

act ← a[act].dcho

fin_si

fin_si

fin_mientras

fin_procedimiento

procedimiento altas(E/S arr: a; E tipoelemento: elemento;

E/S entero: raíz, vacío)

var

entero: act, ant, auxi

inicio

si no árbollleno(vacío) entonces

buscar(a, elemento, act, ant)

si act <> 0 entonces

escribir('Ese elemento ya existe')

si_no

auxi ← vacío

vacío ← a[auxi].dcho

a[auxi].elemento ← elemento

a[auxi].izdo ← 0

a[auxi].dcho ← 0

si ant = 0 entonces

Estructura de datos no lineales (árboles y grafos) 515

raíz ← auxi

si_no

si mayor(a[ant].elemento, elemento) entonces

a[ant].izdo ← auxi

si_no

a[ant].dcho ← auxi

fin_si

fin_si

fin_si

fin_si

fin_procedimiento

procedimiento listado (E arr: a; E entero: raíz)

var

entero: cont

inicio

escribir ('inorden: ')

cont ← 0

inorden (a, raíz, cont)

escribir('El número de nodos es ', cont)

fin_procedimiento

13.4. Escribir un procedimiento que permita contar las hojas de un árbol mediante estructuras dinámicas.

Análisis del problema

Recorrer el árbol, contando, únicamente, los nodos que no tienen hijos.

Diseño del algoritmo

procedimiento contarhojas(E punt: raíz; E/S entero: cont)

inicio

si raíz <> nulo entonces

si (raíz→.izdo = nulo) y (raíz→.dcho = nulo) entonces

cont ← cont+1

fin_si

contarhojas(raíz→.izdo, cont)

contarhojas(raíz→.dcho, cont)

fin_si

fin_procedimiento

13.5. Diseñar una función que permita comprobar si son iguales dos árboles cuyos nodos tienen la siguiente estructura:

tipo

puntero_a nodo: punt

registro : nodo

entero : elemento

punt : izdo, dcho

fin_registro

Análisis del problema

Se trata de una función recursiva que compara nodo a nodo la información almacenada en ambos árboles. Las condiciones

de salida del proceso recursivo serán que:

• Se termine de recorrer uno de los dos árboles.

• Se terminen de recorrer ambos.

• Se encuentre diferente información en los nodos comparados.

516 Fundamentos de programación

Si los árboles terminaron de recorrerse simultáneamente es que ambos tienen el mismo número de nodos y nunca ha

sido diferente la información comparada; por tanto, la función devolverá verdad; en cualquier otro caso la función devolverá

falso.

Diseño del algoritmo

lógico función iguales(E punt: raíz1, raíz2)

inicio

si raíz1 = nulo entonces

si raíz2 = nulo entonces

devolver(verdad)

fin_si

si_no

si raíz2 = nulo entonces

devolver(falso)

si_no

si raíz1→.elemento <> raíz2→.elemento entonces

devolver(falso)

si_no

devolver(iguales(raíz1→.izdo, raíz2→.izdo)

y iguales(raíz1→.dcho, raíz2→.dcho))

fin_si

fin_si

fin_si

fin_función

CONCEPTOS CLAVE

• Árbol.

• Árbol binario.

• Árbol binario de búsqueda.

• Dígrafo.

• Enorden.

• Grafo.

• Grafo dirigido.

• Grafo no dirigido.

• Hoja.

• Lista de adyacencia.

• Matriz de adyacencia.

• Nivel.

• Nodo.

• Postorden.

• Preorden.

• Profundidad.

• Raíz.

• Rama.

• Recorrido de un árbol.

• Subárbol.

RESUMEN

Las estructuras de datos dinámicas árboles y grafos son

muy potentes para la resolución de problemas complejos de

tipo gráfico, jerárquico o en red.

La estructura árbol más utilizada normalmente es el árbol binario. Un árbol binario es un árbol en el que cada

nodo tiene como máximo dos hijos, llamados subárbol izquierdo y subárbol derecho.

En un árbol binario, cada elemento tiene cero, uno o dos

hijos. El nodo raíz no tiene un padre pero sí cada elemento

restante. Cuando un elemento y tiene un padre x, x es un

antecesor o antecedente del elemento y.

La altura de un árbol binario es el número de ramas entre

el raíz y la hoja más lejana más 1. Si el árbol A es vacío.

El nivel o profundidad de un elemento es un concepto

similar al de altura.

Un árbol binario no vacío está equilibrado totalmente si

sus subárboles izquierdo y derecho tienen la misma altura

y ambos son o bien vacíos o totalmente equilibrados.

Los árboles binarios presentan dos tipos característicos:

árboles binarios de búsqueda y árboles binarios de expresiones. Los árboles binarios de búsqueda se utilizan fundamentalmente para mantener una colección ordenada de

datos y los árboles binarios de expresiones para almacenar

expresiones.

Los grafos son otra estructura de datos no lineal y que

tiene gran número de aplicaciones. Los árboles binarios re-

Estructura de datos no lineales (árboles y grafos) 517

presentan estructuras jerárquicas con limitaciones de dos subárboles por cada nodo. Si se eliminan las restricciones de

que cada nodo puede apuntar a dos nodos —como máximo— y que cada nodo puede estar apuntado por otro nodo

—como máximo— nos encontramos con un grafo. Ejemplos de grafos en la vida real los tenemos en la red de carreteras de un estado o región, la red de enlaces ferroviarios

o aéreos nacionales, etc.

Un grafo G consta de dos conjuntos (G = {V, E}):

un conjunto V de vértices o nodos y un conjunto E de aristas (parejas de vértices distintos) que conectan los vértices.

Si las parejas no están ordenadas, G se denomina grafo no

dirigido; si los pares están ordenados, entonces G se denomina grafo dirigido. El término grafo dirigido se suele también designar como dígrafo y el término grafo sin calificación significa grafo no dirigido.

Los grafos se pueden implementar de dos formas típicas: matriz de adyacencia y lista de adyacencia. La elección depende de las necesidades de la aplicación en concreto, ya que cada una de las formas tiene sus ventajas y sus

inconvenientes.

El recorrido de un grafo puede ser en analogía con los

árboles, recorrido en profundidad y recorrido en anchura.

El recorrido en profundidad es aplicable a los grafos dirigidos y a los no dirigidos y es una generalización del recorrido preorden de un árbol. El recorrido en anchura también

es aplicable a grafos dirigidos y no dirigidos, que generaliza el concepto de recorrido por niveles de un árbol.

EJERCICIOS

13.1. Dado un árbol binario de números enteros ordenados, se desea un subalgoritmo que busque un elemento con un proceso recursivo.

13.2. Diseñar un subalgoritmo que busque un elemento en

un árbol binario de números enteros ordenados, realizado con un proceso repetitivo.

13.3. Describir el orden en el que los vértices de los siguientes árboles binarios serán visitados en: a) preorden, b) in-orden, c) post-orden:

(a) 1

2

3

4

5

(b) 1

2

3

4

5

T

(c) 1

2 23

3

5 6

7 8

(d) 1

4 6

7 89

4 5

13.4. Dibujar la expresión árbol para cada una de las siguientes expresiones y dar el orden de visita a los

nodos en: a) pre-orden, b) in-orden, c) post-orden:

1. log n!

2. (a – b) – c

3. a – (b – c)

4. (a < b) y (b < c) y (c < d)

13.5. Escribir un subalgoritmo recursivo que liste los

nodos de un árbol binario en pre-orden.

13.6. Escribir un subalgoritmo que elimine un nodo determinado de un árbol de enteros.

13.7. Se dispone de un árbol de números reales desordenados y se desea escribir un subalgoritmo que inserte un nodo en el lugar correspondiente de acuerdo a

su valor.

13.8. Escribir un subalgoritmo que permita conocer el número de nodos de un árbol binario.

518 Fundamentos de programación

13.9. Considerar el árbol binario.

Listar los nodos del árbol en: a) pre-orden, b) inorden, c) post-orden.

B C

A

D

G

M

Q

L

E

H I

F

J K

N O

CAPÍTULO 14

Recursividad

14.1. La naturaleza de la recursividad

14.2. Recursividad directa e indirecta

14.3. Recursión versus iteración

14.4. Recursión infinita

14.5. Resolución de problemas complejos con

recursividad

CONCEPTOS CLAVE

RESUMEN

EJERCICIOS

PROBLEMAS

La recursividad (recursión) es aquella propiedad que

posee una función por la cual dicha función puede

llamarse a sí misma. Se puede utilizar la recursividad

como una alternativa a la iteración. Una solución recursiva es normalmente menos eficiente en términos

de tiempo de computadora que una solución iterativa

debido a las operaciones auxiliares que llevan consigo

las llamadas suplementarias a las funciones; sin embargo, en muchas circunstancias el uso de la recursión

permite a los programadores especificar soluciones

naturales, sencillas, que serían, en caso contrario, difíciles de resolver. Por esta causa, la recursión es una

herramienta poderosa e importante en la resolución

de problemas y en la programación.

INTRODUCCIÓN

520 Fundamentos de programación

14.1. LA NATURALEZA DE LA RECURSIVIDAD1

Los programas examinados hasta ahora, generalmente estructurados, se componen de una serie de funciones que

llaman unas a otras de modo disciplinado. En algunos problemas es útil disponer de funciones que se llamen a sí

misma. Un subprograma recursivo es un subprograma que se llama a sí mismo ya sea directa o indirectamente. La

recursividad es un tópico importante examinado frecuentemente en cursos de programación y de introducción a las

ciencias de la computación.

En este libro se dará una importancia especial a las ideas conceptuales que soportan la recursividad. En matemáticas existen numerosas funciones que tienen carácter recursivo; de igual modo numerosas circunstancias y situaciones de la vida ordinaria tienen carácter recursivo.

Hasta el momento casi siempre se han visto subprogramas que llaman a otros subprogramas distintos. Así, si se

dispone de dos procedimientos proc1 y proc2, la organización de un programa tal y como se suele haber visto

hasta este momento podría adoptar una forma similar a esta:

procedimiento proc1(...)

inicio

...

fin_procedimiento

procedimiento proc2(...)

inicio

...

proc1(...) // llamada a proc1

...

fin_procedimiento

Cuando diseñan programas recursivos se tendría esta situación:

procedimiento proc1(...)

inicio

...

proc1(...);

...

fin_procedimiento

o bien esta otra:

procedimiento proc1(...)

inicio

...

proc2(...) //llamada a proc2

...

fin_procedimiento

procedimiento proc2(...)

inicio

...

proc1(...) //llamada a proc1

...

fin_procedimiento

1

Las palabras inglesas «recursive» y «recursion» no han sido aceptadas todavía por el Diccionario de la Real Academia de la Lengua Española (www.rae.es). La última edición (22.ª, Madrid, 2001) editada conjuntamente por todas las Academias de la Lengua de España, Latinoamérica y Estados Unidos, recoge sólo los términos sinónimos siguientes en sus acepciones Mat (Matemáticas): recurrencia, «propiedad de aquellas

secuencias en las que cualquier término se puede calcular conociendo los precedentes», y recurrente, «Dicho de un proceso: que se repita».

Recursividad 521

EJEMPLO 14.1

El factorial de un entero no negativo n, escrito n! (y pronunciado n factorial), es el producto

n! = n.(n – 1).(n – 2),...,1

en el cual

0! = 1

1! = 1

2! = 2*1 = 2*1!

3! = 3*2*1 = 3*2!

4¡ = 4*3*2*1 = 4*3!

...

así:

5! = 5 . 4 . 3 . 2 . 1 = 5 . 4! = 120

de modo que una definición recursiva de la función factorial n es:

n! = n*(n – 1)! para n>1

El factorial de un entero n, mayor o igual a 0, se puede calcular de modo iterativo (no recursivo), teniendo presente la definición de n! del modo siguiente:

n! = 1 si n = 0

n! = n * (n – 1)! si n > 0

El algoritmo que resuelve el factorial de forma iterativa de un entero n, mayor o igual que 0, se puede calcular

utilizando un bucle for:

var

entero: contador

real: factorial

inicio

...

factorial ← 1;

desde contador ← n hasta 1 decremento 1

factorial ← factorial * contador

fin_desde

fin

En el caso de implementar una función se requerirá una sentencia de retorno que devuelva el valor del factorial,

tal como

devolver(factorial)

El algoritmo que resuelve la función de modo recursivo ha de tener presente una condición de salida. Así, en el

caso del cálculo de 6!, la definición es 6! = 6 × 5! y 5! de acuerdo a la definición es 5 × 4! Este proceso

continúa hasta que 1! = 1 × 0! por definición. El método de definición de una función en términos de sí misma

se llama en matemáticas una definición inductiva y conduce naturalmente a una implementación recursiva. El caso

base de 0! = 1 es esencial dado que se detiene, potencialmente, una cadena de llamadas recursivas. Este caso base

o condición de salida deben fijarse en cada caso de una solución recursiva. El algoritmo que resuelve n! de modo

recursivo se apoya en la definición siguiente:

522 Fundamentos de programación

n! = 1 si n = 0

n! = n*(n – 1)*(n – 2)*...*1 si n > 0

en consecuencia, el algoritmo mencionado que calcula el factorial será:

si (n = 0) entonces

fac ← 1

si_no

contador = n – 1

fac ← n * fac(contador)

fin_si

Otro pseudocódigo que resuelve la función factorial es:

si n = 1 entonces

fac ← n

si_no

fac ← n*fac(n – 1)

fin_si

Así una función recursiva de factorial es:

entero función factorial(E entero: n)

inicio

si (n = 1) entonces

devolver (1)

si_no

devolver (n * factorial(n – 1))

fin_si

fin_función

Nota

Dado que el valor de un factorial de un número entero aumenta considerablemente a medida que aumenta el

valor de n, es conveniente en el diseño del algoritmo definir el tipo de dato a devolver por la función como un

valor real, al objeto de no tener problema de desbordamiento cuando traduzca a un código fuente en un lenguaje de programación.

EJEMPLO 14.2

Deducir la definición recursiva del producto de números naturales.

El producto a * b, donde a y b son enteros positivos, tiene dos soluciones.

Solución iterativa

a * b = a + a + a + + ... + a _________________________

b veces

Solución recursiva a * b = a si b = 1

a * b = a * (b – 1) + a si b > 1

Así, por ejemplo, 7 × 3 será:

7 * 3 = 7 * 2 + 7 = 7 * 1 + 7 + 7 = 7 + 7 + 7 = 21

Recursividad 523

En pseudocódigo se tiene:

entero funcion producto (E entero, a, b)

inicio

si b = 1 entonces

devolver (a)

si no

devolver (a*producto (a, b-1))

fin_si

fin

EJEMPLO 14.3

Definir la naturaleza de la serie de Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

Se observa en esta serie que comienza con 0 y 1, y tiene la propiedad de que cada elemento es la suma de los

dos elementos anteriores, por ejemplo:

0 + 1 = 1

1 + 1 = 2

2 + 1 = 3

3 + 2 = 5

5 + 3 = 8

...

Entonces se puede decir que:

fibonacci(0) = 0

fibonacci(1) = 1

...

fibonacci(n) = fibonacci(n – 1) + fibonacci(n – 2)

y la definición recursiva será:

fibonacci(n) = n si n = 0 o n = 1

fibonacci(n) = fibonacci(n – 1) + fibonacci(n – 2) si n > = 2

Obsérvese que la definición recursiva de los números de fibonacci es diferente de las definiciones recursivas del

factorial de un número y del producto de dos números. Así, por ejemplo, simplificando el nombre de la función por

fib

fib(6) = fib(5) + fib(4)

o lo que es igual, fib(6) ha de aplicarse en modo recursivo dos veces, y así sucesivamente. Las funciones iterativa

y recursiva implementadas en Java son

public class Fibonacci

{

//Fibonacci iterativo

public static long fibonaccii(int n)

{

long f = 0, fsig = 1;

for (int i = 0; i < n; i++)

{

long aux = fsig;

524 Fundamentos de programación

fsig += f;

f = aux:

}

return(f);

}

//Fibonacci recursivo

public static long fibonaccir(int n)

{

// si n es menor que 0 devuelve –1 como señal de error

if (n < 0)

return –1;

// especificar else no es necesario, ya que

// cuando se ejecuta return se retorna a la sentencia llamadora

// y la siguiente instrucción ya no se ejecuta

if (n == 0)

return(0);

else

if (n == 1)

return(1);

else

return(fibonaccir(n–1)+fibonaccir(n–2));

}

public static void main(String[] args)

{

System.out.println("Fibonacci_iterativo("+8+")="+fibonaccii(8));

System.out.println("Fibonacci_recursivo("+8+")="+fibonaccii(8));

}

}

14.2. RECURSIVIDAD DIRECTA E INDIRECTA

En recursión directa el código del subprograma recursivo F contiene una sentencia que invoca a F, mientras que en

recursión indirecta el subprograma F invoca al subprograma G que invoca a su vez al subprograma P, y así sucesivamente hasa que se invoca de nuevo al subprograma F.

Si una función, procedimiento o método se invoca a sí misma, el proceso se denomina recursión directa; si una

función, procedimiento o método puede invocar a una segunda función, procedimiento o método que a su vez

invoca a la primera, este proceso se conoce como recursión indirecta o mutua.

Un requisito para que un algoritmo recursivo sea correcto es que no genere una secuencia infinita de llamadas

sobre sí mismo. Cualquier algoritmo que genere una secuencia de este tipo no puede terminar nunca. En consecuencia, la definición recursiva debe incluir un componente base (condición de salida) en el que f(n) se defina directamente (es decir, no recursivamente) para uno o más valores de n.

Debe existir una “forma de salir” de la secuencia de llamadas recursivas. Así en la función f(n) = n! para n entero

1 n ≤ 1

f(n){ n*f(n – 1) n > 1

la condición de salida o base es f(n) = 1 para n ≤ 1.

Recursividad 525

En el caso de la serie de Fibonacci

F0 = 0, F1 = 1, Fn = Fn-1 + Fn-2 para n > 1.

F0 = 0 y F1 = 1 constituyen el componente base o condiciones de salida y Fn = Fn-1 + Fn-2 es el componente recursivo.

C++ permite escribir funciones recursivas. Una función recursiva correcta debe incluir un componente base o

condición de salida.

PROBLEMA 14.1

Escribir una función recursiva en C++ que calcule el factorial de un número n y un programa que maneje dicha

función.

Recordemos que

n! = 1 si n = 0

n! = n*(n – 1)! si n ≥ 1

La función recursiva que calcula n!

int Factorial (int n)

{

// cálculo de n!

if (n <= 1)

return 1;

return n * Factorial(n – 1);

}

En el algoritmo anterior se ha considerado que el valor resultante es de tipo entero; sin embargo, observe la secuencia de valores de la función factorial.

n n!

0

1

2

3

4

5

6

7

8

9

10

1

1

2

6

24

120

720

5040

40320

362880

3628800

Como se puede ver, los valores crecen muy rápidamente, y para n = 8 ya sobrepasa el valor normal del mayor

entero manejado en computadoras de 16 bits (32767). Por consiguiente, será preciso cambiar el tipo de dato devuelto que ha de ser float, double, unsigned int, long, etc. En consecuencia, el programa fac.cpp que calcula

el factorial de un número puede ser:

//Programa fac.cpp

#include <iostream>

526 Fundamentos de programación

#using namespace std;

// en C++ las funciones han de ser declaradas

// o definidas antes de su uso

double Factorial (int n);

int main()

{

// declaración

int num;

// escribir ('Por favor introduzca un número: ')

cout << "Por favor introduzca un número: ";

// leer(num)

cin >> num;

// escribir (num, ' != ', Factorial(num); endl)

//endl significa salto de línea

cout << num <<" != " << Factorial(num) << endl;

// devolver exito, es decir ejecución válida

return 0;

}

// definición de la función Factorial

// el paso de parámetros de tipo simple por defecto es por valor

double Factorial (int n)

{

if (n <=1)

return (1);

else

return (n * Factorial(n – 1));

// en C++ los paréntesis en la sentencia return son opcionales

}

Una variante de este programa podría ser el cálculo del factorial correspondiente a los números naturales 0 a 10.

Para ello bastaría sustituir la función main anterior por una función tal como ésta e incluyendo una llamada al archivo #include <iomanip>

// Programa principal

int main()

{

int i;

for (i = 0; i<=10; i++)

cout << setw(2) << i <<" != " << Factorial(i) << endl;

// setw da formato a la salida y establece la anchura del

// campo a 2

return 0;

}

PROBLEMA 14.2

Escribir una función de Fibonacci de modo recursivo y un programa que manipule dicha función, de modo que calcule el valor del elemento de acuerdo a la posición ocupada en la serie.

Recursividad 527

Nota

El código fuente de este programa se ha escrito en lenguaje C++.

// Función de Fibonacci: fibo.cpp

#include <iostream>

#using namespace std;

long fibonacci (long n);

int main()

{

long resultado, num;

cout << "Introduzca un entero : ";

cin >> num;

resultado = fibonacci (num);

cout << "El valor de Fibonacci(" << num << ")= " << resultado << endl;

return 0;

}

// definición recursiva de la función de fibonacci

long fibonacci(long n)

{

if ((n == 0) || (n == 1))

return n;

// no es necesaria la especificación de else, pero se puede poner

return fibonacci(n - 1) + fibonacci (n - 2);

}

La salida resultante de la ejecución del programa anterior:

Introduzca un entero : 2

El valor de Fibonacci (2) = 1

Introduzca un entero : 20

El valor de Fibonacci (20) = 832040

14.2.1. Recursividad indirecta

La recursividad indirecta se produce cuando un subprograma llama a otro, que eventualmente terminará llamando de

nuevo al primero. El programa ALFABETO.CPP visualiza el alfabeto utilizando recursión mutua o indirecta.

Nota

El código fuente de este programa también se ha escrito en lenguaje C++.

// Listado ALFABETO.CPP

#include <iostream>

#include <stdio.h>

528 Fundamentos de programación

using namespace std;

// A y B equivalen a procedimientos

void A(int c);

void B(int c);

int main()

{

A('Z');

cout << endl;

return 0;

}

void A(int c)

{

if (c > 'A')

B(c);

putchar(c);

}

void B(int c)

{

A(--c);

}

El programa principal llama a la función recursiva A() con el argumento 'Z' (la última letra del alfabeto). La

función A examina su parámetro c. Si c está en orden alfabético después que 'A', la función llama a B(), que inmediatamente llama a A(), pasándole un parámetro predecesor de c. Esta acción hace que A() vuelva a examinar c,

y nuevamente una llamada a B(), hasta que c sea igual a 'A'. En este momento, la recursión termina ejecutando

putchar() veintiséis veces y visualizando el alfabeto, carácter a carácter.

14.2.2. Condición de terminación de la recursión

Cuando se implementa un subprograma recursivo será preciso considerar una condición de terminación, ya que en

caso contrario el subprograma continuaría indefinidamente llamándose a sí mismo y llegaría un momento en que la

memoria se podría agotar. En consecuencia, sería necesario establecer en cualquier subprograma recursivo la condición de parada que termine las llamadas recursivas y evitar indefinidamente las llamadas. Así, por ejemplo, en el caso

de la función factorial, definida anteriormente, la condición de salida puede ser cuando el número sea 1 o 0, ya

que en ambos casos el factorial es 1.

real función factorial(E entero: n)

inicio

si(n = 1) o (n = 0) entonces

devolver (1)

si_no

devolver (n * factorial (n - 1))

fin_si

fin_función

14.3. RECURSIÓN VERSUS ITERACIÓN

En las secciones anteriores se han estudiado varias funciones que se pueden implementar fácilmente o bien de modo

recursivo o bien de modo iterativo. En esta sección compararemos los dos enfoques y examinaremos las razones por

las que el programador puede elegir un enfoque u otro según la situación específica.

Recursividad 529

Tanto la iteración como la recursión se basan en una estructura de control: la iteración utiliza una estructura

repetitiva y la recursión utiliza una estructura de selección. La iteración y la recursión implican ambas repetición:

la iteración utiliza explícitamente una estructura repetitiva mientras que la recursión consigue la repetición mediante

llamadas repetidas. La iteración y recursión implican cada una un test de terminación (condición de salida). La iteración termina cuando la condición del bucle no se cumple mientras que la recursión termina cuando se reconoce un

caso base o la condición de salida se alcanza.

La recursión tiene muchas desventajas. Se invoca repetidamente al mecanismo de recursividad y en consecuencia

se necesita tiempo suplementario para realizar las mencionadas llamadas.

Esta característica puede resultar cara en tiempo de procesador y espacio de memoria. Cada llamada de una

función recursiva produce que otra copia de la función (realmente sólo las variables de función) sea creada; esto

puede consumir memoria considerable. Por el contrario, la iteración se produce dentro de una función, de mo do

que las operaciones suplementarias de las llamadas a la función y asignación de memoria adicional son omitidas.

En consecuencia, ¿cuáles son las razones para elegir la recursión? La razón fundamental es que existen numerosos problemas complejos que poseen naturaleza recursiva y, en consecuencia, son más fáciles de implementar con

algoritmos de este tipo. Sin embargo, en condiciones críticas de tiempo y de memoria, es decir, cuando el consumo

de tiempo y memoria sean decisivos o concluyentes para la resolución del problema, la solución a elegir debe ser,

normalmente, la iterativa.

Cualquier problema que se puede resolver recursivamente se puede resolver también iterativamente (no recursivamente). Un enfoque recursivo se elige normalmente con preferencia a un enfoque iterativo cuando el enfoque recursivo es más natural para la resolución del problema y produce un programa más fácil de comprender y depu rar. Otra razón para elegir una solución recursiva es que una solución iterativa puede no ser clara

ni evidente.

Consejo de programación

Se ha de evitar utilizar recursividad en situaciones de rendimiento crítico o exigencia de altas prestaciones en tiempo

y memoria, ya que las llamadas recursivas emplean tiempo y consumen memoria adicional.

Consejo de carácter general

Si una solución de un problema se puede expresar iterativa o recursivamente con igual facilidad, es preferi ble

la solución iterativa, ya que se ejecuta más rápidamente (no existen llamadas adicionales a funciones que

consumen tiempo de proceso) y utiliza menos memoria (la pila necesaria para almacenar las sucesivas llamadas necesarias en la recursión). Hay veces, sin embargo, que, pese a todo, es preferible la solución recursiva.

EJEMPLO 14.4

La función factorial de un número ya expuesta anteriormente ofrece un ejemplo claro de comparación entre funciones definidas de modo iterativo o modo recursivo y, a continuación, se muestra su implementación en C#.

El factorial n!, de un número n era

0! = 1

n! = n * (n - 1)! para n > 0

Solución recursiva

// código en C#

public class Prueba1

530 Fundamentos de programación

{

// factorial recursivo

// Precondición n está definido y n >= 0

// Postcondición ninguna

// Devuelve n!

public static long factorial(int n)

{

if (n < 0)

return – 1;

if (n == 0)

return 1;

else

return n * factorial(n – 1);

}

public static void main()

{

// escribir(factorial(4))

System.Console.WriteLine(factorial(4));

}

}

Solución iterativa

// código en C#

public class Prueba2

{

// factorial iterativo

// Precondición n está definido y n >= 0

// Postcondición ninguna

// Devuelve n!

public static long factorial(int n)

{

if (n < 0)

return – 1;

long fact = 1;

while (n > 0)

{

fact = fact * n;

n = n – 1;

}

return fact;

}

public static void main()

{

// escribir(factorial(4))

System.Console.WriteLine(factorial(4));

}

}

Directrices en la toma de decisión iteración/recursión

1. Considérese una solución recursiva sólo cuando una solución iterativa sencilla no sea posible.

2. Utilícese una solución recursiva sólo cuando la ejecución y eficiencia de la memoria de la solución esté dentro de límites aceptables considerando las limitaciones del sistema.

Recursividad 531

14.4. RECURSIÓN INFINITA

La iteración y la recursión pueden producirse infinitamente. Un bucle infinito ocurre si la prueba o test de continuación de bucle nunca se vuelve falsa; una recursión infinita ocurre si la etapa de recursión no reduce el problema en

cada ocasión de modo que converja sobre el caso base o condición de salida.

En realidad la recursión infinita significa que cada llamada recursiva produce otra llamada recursiva y ésta a su

vez otra llamada recursiva y así para siempre. En la práctica dicho código se ejecutará hasta que la computadora

agota la memoria disponible y se produzca una terminación anormal del programa.

El flujo de control de un algoritmo recursivo requiere tres condiciones para una terminación normal:

• Un test para detener (o continuar) la recursión (condición de salida o caso base).

• Una llamada recursiva (para continuar la recursión).

• Un caso final para terminar la recursión.

EJEMPLO 14.5

Se desea calcular la suma de los primeros N enteros positivos.

La función no recursiva que realiza la tarea solicitada es:

entero función CalculoSuma (E entero: N)

var

entero: suma, i

inicio

suma ← 0

desde i ← 1 hasta N hacer

suma ← suma + i

fin_desde

devolver (suma)

fin_función

La función CalculoSuma implementada recursivamente requiere la definición previa de la suma de los primeros

N enteros matemáticamente en forma recursiva, tal como se muestra a continuación:

1 si N = 1

suma(N) = { N + suma(N–1) en caso contrario

La definición anterior significa que si N es 1, entonces la función suma(N) toma el valor 1. En caso contrario,

significa que la función suma(N) toma el valor resultante de la suma de N y el resultado de suma(N–1). Por ejemplo,

la función suma(5) se evalúa tal como se muestra en la Figura 14.1 de la página siguiente.

El pseudocódigo fuente de la función recursiva suma es:

entero función suma(E entero: n)

inicio

// test para parar o continuar (condición de salida)

si (n = 1) entonces

devolver (1)

3. Si son posibles las dos soluciones, iterativa y recursiva, la solución recursiva siempre requerirá más tiempo

y espacio debido a las llamadas adicionales que se realizan.

4. En ciertos problemas, la recursión conduce naturalmente a soluciones que son mucho más fáciles de leer y

comprender que su correspondiente iterativa. En estos casos los beneficios obtenidos con la claridad de la

solución suelen compensar el coste extra (en tiempo y memoria) de la ejecución de un programa recursivo.

532 Fundamentos de programación

//caso final - se detiene la recursión

si_no

devolver(n + suma (n – 1))

//caso recursivo

//la recursión continúa con una llamada recursiva

fin_si

fin_función

y el código fuente en Turbo Pascal es:

program Sumas;

{solución interactiva}

function CalculoSuma (N: integer): integer;

var

suma, i: integer;

begin

suma := 0;

for i:= 1 to N do

suma := suma + i;

CalculoSuma := suma

end;

{solución recursiva}

function suma(n: integer): integer;

begin

{ test para parar o continuar (condición de salida)}

if n = 1 then

suma := 1

15

suma(5) = 5 + suma(4) 10

suma(4) = 4 + suma(3) 6

suma(3) = 3 + suma(2) 3

suma(2) = 2 + suma(1)

1

suma(1) = 1

Figura 14.1. Secuencia de llamadas recursivas que evalúan la función Suma(N) (en el ejemplo Suma(4)).

Recursividad 533

{ caso final – se detiene la recursión}

la recursión continúa con una llamada recursiva }

else

suma := n + suma (n – 1);

end;

begin

writeln('Suma recursiva ', suma(4))

writeln('Suma iterativa ', CalculoSuma(4))

end

Cuando se realizan llamadas recursivas se han de pasar argumentos diferentes de los parámetros de entrada; así,

en el ejemplo de la función suma, el argumento que se pasa en la función recursiva es n – 1 y el parámetro es n. La

Figura 14.2 muestra el flujo de control de la función suma de modo recursivo.

n = 5

ent suma(int n)

inicio

si(n = 1)

devolver 1;

sino

devolver n + suma(n – 1);

fin

ent suma(int n)

inicio

si(n = 1)

devolver 1;

sino

devolver n + suma(n – 1);

fin

15

n = 4

10

6 n = 3

...

Figura 14.2. Flujo de control de la función suma recursiva.

PROBLEMA 14.2

Deducir cuál es la condición de salida de la función mcd() que calcula el mayor divisor común de dos números enteros b1 y b2 (el mcd, máximo común divisor, es el entero mayor que divide a ambos números) y un programa que

la manipule.

El mcd de los enteros b1 y b2 se define como el entero mayor que divide a ambos números. El mcd no está definido si b1 y b2 son cero. Los valores negativos de b1 y b2 se sustituyen por su valores absolutos. Supongamos dos

números 6 y 124; el procedimiento clásico de obtención del mcd es la realización de divisiones sucesivas, se comienza dividiendo ambos números (124 entre 6) si el resto no es 0, se divide el número menor por el resto y así sucesivamente hasta que el resto sea 0.

534 Fundamentos de programación

124 6

04 20

64 42

21 02

(mcd = 2)

20 1 2

124 6 4 2

420

mcd = 2

En el caso de 124 y 6, el mcd es 2. Suponga ahora que los números son b1=18 y b2=45

18 45

18 0

45 18

09 2

18 9

02

(mcd = 9)

El mcd de 18 y 45 es 9. En consecuencia, la condición de salida es que el resto sea cero. Por tanto:

1. Si b2 es cero, la solución es b1.

2. Si b2 no es cero, la solución es mcd(b2, b1 mod b2).

El código fuente de la función es:

entero función mcd(E entero: b1, b2)

inicio

si (b2 <> 0) entonces // condición de salida

devolver ( mcd (b2, b1 mod b2))

si_no

devolver (b1)

fin_si

fin_función

Un programa en C++ que gestiona la función mcd es mcd.cpp.

#include <iostream>

using namespace std;

// Programa mcd.cpp, escrito en lenguaje C++

int mcd(int n, int m);

void main()

{

// datos locales

int m, n;

cout << "Introduzca dos enteros positivos :";

cin >> m >> n;

cout << endl;

cout << "El máximo común divisor es : " << mcd(m, n) << endl;

}

// Función recursiva mcd

int mcd(int n,int m)

// devuelve el máximo común divisor de m y n

Recursividad 535

{

if (m != 0) // condición de salida

return mcd(m, n % m);

else

return n;

} // final de mcd

Al ejecutarse el programa se produce la siguiente salida:

Introduzca dos enteros positivos : 6 40

El máximo común divisor es : 2

El código de la función recursiva en Turbo Pascal es

function mcd (n, m: integer): integer;

begin

if m <> 0 then

mcd := mcd(m, n mod m)

else

mcd := n

end;

14.5. RESOLUCIÓN DE PROBLEMAS COMPLEJOS CON RECURSIVIDAD

Muchos problemas de computadora tienen una formulación simple y elegante que se traduce directamente a código

recursivo. En esta sección se describen una serie de ejemplos que incluyen problemas clásicos resueltos mediante

recursividad. Entre ellos se destacan problemas matemáticos, las Torres de Hanoi, método de búsqueda binaria, ordenación rápida, árboles de expresión, etc. Explicamos con detalle algunos de ellos.

14.5.1. Torres de Hanoi

Este juego (un algoritmo clásico) tiene sus orígenes en la cultura oriental y en una leyenda sobre el Templo de Brahma. El problema en cuestión supone la existencia de 3 varillas o postes en los que se alojaban discos, cada disco es

ligeramente inferior en diámetro al que está justo debajo de él, y pretende determinar los movimientos necesarios

para trasladar los discos de una varilla a otra cumpliendo las siguientes reglas:

• En cada movimiento sólo puede intervenir un disco.

• Nunca puede quedar un disco sobre otro de menor tamaño.

La Figura 14.3 ilustra el problema. Los cuatro discos situados en la varilla I se desean trasladar a la varilla F

conservando la condición de que cada disco sea ligeramente inferior en diámetro al que tiene situado debajo de él.

varilla I varilla C varilla F

Figura 14.3.

536 Fundamentos de programación

Este problema es claramente recursivo, pues mover cuatro discos de la varilla I a la F consiste en trasladar los

tres discos superiores de la varilla origen a otra considerada como auxiliar (C). Figuras 14.3 y 14.4,

varilla I varilla C varilla F

Figura 14.4.

trasladar el disco más grande de la varilla origen al destino (de I a F). Figuras 14.4 (antes) y 14.5 (después).

varilla I varilla C varilla F

Figura 14.5.

y pasar los tres de la varilla auxiliar al destino. Figura 14.5 (antes) y 14.6 (después).

varilla I varilla C varilla F

Figura 14.6.

Nuevamente se observa que mover los tres discos superiores de un origen a un destino requiere mover dos de

origen a auxiliar, uno de origen a destino y dos de auxiliar a destino. Por último, trasladar dos discos de origen a

destino implica trasladar uno de origen a auxiliar, otro de origen a destino y completar la operación pasando el de la

varilla auxiliar a destino.

Los movimientos que se realizarían detallados gráficamente para el caso de N = 3, son

I C F

situación

inicial

Recursividad 537

I C F

2.o

I C F

3.o

4.o

I C F

I C F

1.o

5.o

I C F

538 Fundamentos de programación

I C F

6.º

ICF

7.º

Diseño del algoritmo

El algoritmo se escribe generalizando para n discos y tres varillas. La función de Hanoi declara las varillas o postes

como objetos cadena. En la lista de parámetros, el orden de las variables o varillas es:

varinicial varcentral varfinal

lo que implica que se están moviendo discos desde la varilla inicial a la final utilizando la varilla central como auxiliar para almacenar los discos. Si n = 1 se tiene la condición de parada, ya que se puede manejar moviendo el único

disco desde la varilla inicial a la varilla final. El algoritmo sería el siguiente:

1. Si n es 1

1.1 Mover el disco 1 de varinicial a varfinal

2. Si_no

1.2 Mover n – 1 discos desde varinicial hasta la varilla auxiliar utilizando

varfinal

1.3 Mover el disco n desde varinicial a varfinal

1.4 Mover n – 1 discos desde la varilla auxiliar o central a varfinal utilizando

la varilla inicial.

Es decir, si n es 1, se alcanza la condición de salida o terminación del algoritmo. Si n es mayor que 1, las etapas

recursivas 1.2, 1.3 y 1.4 son tres subproblemas más pequeños, que aproximan a la condición de salida.

Las Figuras 14.7, 14.8 y 14.9 muestran el algoritmo anterior:

Etapa 1: Mover n – 1 discos desde varilla inicial (I).

varilla inicial varilla central varilla final

Figura 14.7.

Recursividad 539

Etapa 2: Mover un disco desde I a F.

varilla inicial varilla central varilla final

Figura 14.8.

Etapa 3: Mover n – 1 discos desde varilla central (C).

varilla inicial varilla central varilla final

Figura 14.9.

La primera etapa en el algoritmo mueve n – 1 discos desde la varilla inicial a la varilla central utilizando la varilla final. Por consiguiente, el orden de parámetros en la llamada a la función recursiva es varinicial, varfinal y

varcentral.

// utilizar varfinal como almacenamiento auxiliar

Hanoi(n – 1, varinicial, varfinal, varcentral);

La segunda etapa mueve simplemente el disco mayor desde la varilla inicial a la varilla final:

escribir "mover", varinicial, "a", varfinal, fin de línea;

La tercera etapa del algoritmo mueve n – 1 discos desde la varilla central a la varilla final utilizando varinicial

para almacenamiento temporal. Por consiguiente, el orden de parámetros en la llamada a la función recursiva es:

varcentral, varinicial y varfinal.

// utilizar varinicial como almacenamiento auxiliar

Hanoi(n – 1, varcentral, varinicial, varfinal);

Implementación de las Torres de Hanoi en C++

La implementación del algoritmo se apoya en los nombres de las tres varillas o alambres "inicial", "central"

y "final" que se pasan como parámetros a la función. El programa comienza solicitando al usuario que introduzca

el número de discos N. Se llama a la función recursiva Hanoi para obtener un listado de los movimientos que transferirán los N discos desde la varilla "inicial" a la varilla "final". El algoritmo requiere 2N – 1 movimientos. Para

el caso de 10 discos, el juego requerirá 1.023 movimientos. En el caso de prueba para N = 3, el número de movimientos es 23

– 1 = 7.

540 Fundamentos de programación

// archivo Torres.cpp

// función recursiva Torres de Hanoi

void Hanoi(char varinicial, char varfinal, char varcentral, int n)

{

if ( n == 1)

cout << " Mover disco 1 de varilla " << varinicial << " a varilla "

<< varfinal << endl;

else

{

Hanoi(varinicial, varcentral, varfinal, (n - 1);

cout << " Mover disco " << n << " desde varilla " << varinicial <<

" a varilla " << varfinal << endl;

Hanoi(varcentral, varfinal, varinicial, n - 1);

}

}

Una ejecución de la función para el caso de mover tres discos desde las varillas A a C tomando la varilla B como

varilla central o auxiliar, se puede conseguir con la siguiente sentencia:

Hanoi ('A', 'C', 'B', 3);

que resuelve el problema de tres discos desde A a C. La salida generada sería:

Mover disco 1 de varilla A a varilla C

Mover disco 2 de varilla A a varilla B

Mover disco 1 de varilla C a varilla B

Mover disco 3 de varilla A a varilla C

Mover disco 1 de varilla B a varilla A

Mover disco 2 de varilla B a varilla C

Mover disco 1 de varilla A a varilla C

Consideraciones de eficiencia en las Torres de Hanoi

Es de destacar que la función Hanoi resolverá el problema de las Torres de Hanoi para cualquier número de discos.

El problema de tres discos se resuelve en un total de 7 (23

– 1) llamadas a la función Hanoi mediante 7 movimientos de disco. El problema de cinco discos se resuelve con 31 (25

– 1) llamadas y 31 movimientos. En general, como

ya se ha expresado anteriormente, el número de movimientos requeridos para resolver el problema de n discos es

2n

– 1. Cada llamada a la función requiere la asignación e inicialización de un área local de datos en la memoria, por

lo que el tiempo de computadora se incrementa exponencialmente con el tamaño del problema. Por estas razones, la

ejecución del programa con un valor de n mayor que 10 requiere gran cantidad de prudencia para evitar desbordamientos de memoria y ralentización de tiempo.

14.5.2. Búsqueda binaria recursiva

Recordemos que la búsqueda binaria era aquel método de búsqueda de una clave especificada dentro de una lista o

array ordenado de n elementos que realizaba una exploración de la lista hasta que se encontraba o no la coincidencia

con la clave especificada. El algoritmo de búsqueda binaria se puede describir recursivamente.

Supóngase que se tiene una lista ordenada A con un límite inferior y un límite superior. Dada una clave (valor

buscado) se comienza la búsqueda en la posición central de la lista (índice central).

Inferior Central Superior

Central = (inferior + superior)div 2 Comparar A[central] y clave

Recursividad 541

Si se produce coincidencia (se encuentra la clave), se tiene la condición de terminación que permite detener la

búsqueda y devolver el índice central. Si no se produce la coincidencia (no se encuentra la clave), dado que la lista

está ordenada, se centra la búsqueda en la “sublista inferior” (a la izquierda de la posición central) o en la “sublista

derecha” (a la derecha de la posición central).

1. Si clave < A[central], el valor buscado sólo puede estar en la mitad izquierda de la lista con elementos

en el rango inferior a central – 1.

Clave •

Inferior Central Superior

Búsqueda en sublista izquierda

[inferior..central -1]

2. Si clave > A[central], el valor buscado sólo puede entrar en la mitad derecha de la lista con elementos

en el rango de índices, Central + 1 a Superior.

Clave •

Inferior Central Superior

Búsqueda en sublista derecha

[central + 1..superior]

3. El proceso recursivo continúa la búsqueda en sublistas más y más pequeñas. La búsqueda termina o con éxito (aparece la clave buscada) o sin éxito (no aparece la clave buscada), situación que ocurrirá cuando el límite superior de la lista sea más pequeño que el límite inferior. La condición Inferior > Superior será

la condición de salida o terminación y el algoritmo devuelve el índice – 1.

En notación matemática y algorítmica se podría representar la búsqueda binaria de la siguiente forma:

BusquedaBR(inferior, superior, clave) // BR, binaria recursiva

=

{ devolver no encontrada

si inferior > superior

devolver central

si elemento[central] = clave

devolver BusquedaBR(central + 1, superior, clave)

si elemento[central] < clave

devolver BusquedaBR(inferior, central - 1, clave

si elemento[central] > clave

en donde central es el punto central entre inferior y superior. Su codificación en Java podría ser:

public class Bbin

{

private int busquedaBinaria(int[] a, int iz, int de, int c)

{

int central;

if (de < iz)

return(– 1);

else

{

central = (iz + de)/2;

if (c < a[central])

return(busquedaBinaria(a, iz, central – 1, c));)

542 Fundamentos de programación

else

if (a[central] < c)

return(busquedaBinaria(a, central + 1, de, c));

else

return(central);

}

}

public int búsquedaB(int[] a, int c)

{

// los arrays en Java comienzan con el subíndice 0

// a.length se encuentra predefinido y devuelve

// la longitud del array

return(busquedaBinaria(a,0,a.length – 1,c));

}

}

14.5.3. Ordenación rápida (QuickSort)

El algoritmo conocido como quicksort (ordenación rápida) recibe su nombre de su autor, Tony Hoare. La idea del algoritmo es simple, se basa en la división en particiones de la lista a ordenar. El método es, posiblemente, el más pequeño de código, más rápido, más elegante y más interesante y eficiente de los algoritmos conocidos de ordenación.

El método se basa en dividir los n elementos de la lista a ordenar en tres partes o particiones: una partición izquierda, una partición central que sólo contiene un elemento denominado pivote o elemento de partición y una partición derecha. La partición o división se hace de tal forma que todos los elementos de la primera sublista (partición

izquierda) son menores que todos los elementos de la segunda sublista (partición derecha). Las dos sublistas se ordenan entonces independientemente.

La lista se divide en particiones (sublistas) eligiendo uno de los elementos de la lista y se utiliza como pivote o

elemento de partición. Si se elige una lista cualquiera con los elementos en orden aleatorio, se puede elegir cualquier

elemento de la lista como pivote; por ejemplo, el primer elemento de la lista. Si la lista tiene algún orden parcial, que

se conoce, se puede tomar otra decisión para el pivote. Idealmente, el pivote se debe elegir de modo que se divida la

lista exactamente por la mitad, de acuerdo al tamaño relativo de las claves. Por ejemplo, si se tiene una lista de enteros de 1 a 10, 5 o 6 serían pivotes ideales, mientras que 1 o 10 serían elecciones “pobres” de pivotes.

Una vez que el pivote ha sido elegido, se utiliza para ordenar el resto de la lista en dos sublistas: una tiene todas

las claves menores que el pivote y la otra en la que todos los elementos (claves) son mayores que o iguales que el

pivote (o al revés). Estas dos listas parciales se ordenan recursivamente utilizando el mismo algoritmo; es decir, se

llama sucesivamente al propio algoritmo quicksort. La lista final ordenada se consigue concatenando la primera sublista, el pivote y la segunda lista, en ese orden, en una única lista. La primera etapa de quicksort es la división o

“particionado” recursivo de la lista hasta que todas las sublistas constan de sólo un elemento.

EJEMPLO 14.6

1. lista inicial

pivote elegido

2 96 18 38 12 45 10 55 81 43 39

39

2 10 18 38 12 39 96 55 81 43 45

<= pivote >= pivote

pivote

2. lista inicial 13 81 92 43 65 31 57 26 75 0

pivote

0 13 92 43 65 31 57 26 75 81

<= pivote >= pivote

pivote

Recursividad 543

EJEMPLO 14.7 (Pivote: primer elemento de la lista)

1. Lista original 5218379

pivote elegido 5

sublista izquierda1, Izqda1 (elementos menores que 5) 213

sublista derecha1, Dcha1 (elementos mayores o iguales a 5) 879

2. Sublista Izda1 213

sublista Izda2 1

pivote2 sublista Dcha2 3

Sublista Izda1 Izda pivote2 Dcha

123

3. Sublista Dcha1 879

sublista Izda2 7

pivote3 sublista Dcha2 9

Sublista Dcha1 Izda pivote3 Dcha

789

4. Lista ordenada final

Sublista izquierda Pivote Sublista derecha

1 2 3 5 7 8 9

El algoritmo quicksort requiere una estrategia de partición y la selección idónea del pivote. Las etapas fundamentales del algoritmo dependen del pivote elegido, aunque la estrategia de partición suele ser similar. La primera etapa

en el algoritmo de partición es obtener el elemento pivote; una vez que se ha seleccionado se ha de buscar el sistema

para situar en la sublista izquierda todos los elementos menores o iguales que el pivote y en la sublista derecha todos

los elementos mayores que el pivote y dejar el pivote como separador de ambas sublistas.

EJEMPLO 14.8

Lista: 8 1 4 9 6 3 5 2 7 0

Etapa 1:

En esta etapa se efectúa la selección del pivote. Lo primero que se hace es calcular la posición central y si el

primer elemento es mayor que el central se intercambian,

Lista: 6 1 4 9 8 3 5 2 7 0

si el primer elemento es mayor que el último, se intercambian

Lista: 0 1 4 9 8 3 5 2 7 6

544 Fundamentos de programación

si el central es mayor que el último, se intercambian.

Lista: 0 1 4 9 6 3 5 2 7 8

Se toma ahora el central como pivote y se intercambia con el elemento extremo.

Pivote 6

Lista: 0 1 4 9 8 3 5 2 7 6

Etapa 2:

La etapa 2 requiere mover todos los elementos menores al pivote, entre el primero y el penúltimo, a la parte izquierda del array y los elementos mayores a la parte derecha.

0 1 4 9 8 3 5 2 7 6

Para ello se recorre la lista de izquierda a derecha utilizando un contador i que se inicializa en la posición más

baja (Inferior) buscando un elemento mayor al pivote. También se recorre la lista de derecha a izquierda buscando un elemento menor. Para hacer esto se utilizará un contador j inicializado en la posición más alta, Superior-1.

El contador i se detiene en el elemento 9 (mayor que el pivote) y el contador j se detiene en el elemento 2 (menor que el pivote).

0 1 4 9 8 3 5 2 7 6

i j

Ahora se intercambian 9 y 2 para que estos dos elementos se sitúen correctamente en cada sublista.

0 1 4 2 8 3 5 9 7 6

A medida que el algoritmo continúa, i se detiene en el elemento mayor, 8, y j se detiene en el menor, 5.

0 1 4 2 8 3 5 9 7 6

i j

Se intercambian los elementos mientras que i y j no se cruzan, por tanto se intercambian 8 y 5.

0 1 4 2 8 3 5 9 7 6

Continúa la exploración.

0 1 4 2 5 3 8 9 7 6

j i

En esta posición los contadores i y j se encuentran sobre el mismo elemento del array y en este caso se detiene

la búsqueda y no se realiza ningún intercambio, ya que el elemento al que accede el contador j está ya correctamente situado. Las dos sublistas ya han sido creadas (la lista original se ha dividido en dos particiones).

0 1 4 2 5 3 8 9 7 6

i–1 i i+1

Ahora ya lo único que se necesita es intercambiar el elemento que está en la posición i con el elemento pi vote.

Recursividad 545

Etapa 3:

Intercambiar el elemento de la posición i con el pivote, de modo que se tendrá la secuencia prevista inicialmente:

0 1 4 2 5 3 6 9 7 8

sublista izquierda pivote sublista derecha

Resumiendo el proceso general sería:

8149635270

8

7 9

5

012

3

5 4

4

6

014253 978

0 2

1

14.5.3.1. Algoritmo quicksort

El primer problema a resolver en el diseño del algoritmo de quicksort es seleccionar el pivote. Aunque la posición

del pivote, en principio puede ser cualquiera, una de las decisiones más ponderadas es aquella que considera el pivote como el elemento central o próximo al central de la lista. La Figura 14.10 muestra las operaciones del algoritmo

para ordenar la lista de elementos enteros L.

// algoritmo quicksort

// ordenar a[0:n-1]

Seleccionar un elemento de a[0:n-1] como elemento central

(este elemento es el pivote)

Dividir los elementos restantes en particiones izquierda y derecha,

de modo que ningún elemento de la izquierda tenga una clave (valor) mayor que

el pivote y que ningún elemento a la derecha tenga una clave más pequeña que la

del pivote.

Ordenar la partición izquierda utilizando quicksort recursivamente.

Ordenar la partición derecha utilizando quicksort recursivamente.

14.5.4. Ordenación MERGESORT

La idea básica de este método de ordenación es la mezcla (merge) de listas ya ordenadas. El algoritmo puede considerarse que aplica la técnica “divide y vence”, el proceso es simple: si se ordena la primera mitad de la lista, se ordena la segunda mitad de la lista y una vez ordenadas se mezclan, la mezcla da lugar a una lista de elementos ordenada. A su vez, la ordenación de la sublista mitad sigue los mismos pasos, ordenar la primera mitad, ordenar la

segunda mitad y mezclar. La sucesiva división de la lista actual en dos hace que el problema (número de elementos)

cada vez sea mas pequeño; así hasta que la lista actual tenga un elemento y, por tanto, se considera ordenada, es el

caso base y a partir de dos sublistas de un número mínimo de elementos se mezclan, dando cada vez lugar a listas

ordenadas de cada vez más elementos hasta alcanzar la lista total.

546 Fundamentos de programación

Es decir, que el método consiste, pues, en dividir el vector por su posición central en dos partes y tratar análogamente cada una de ellas hasta que consten de un único elemento. Hay que tener en cuenta que un vector con un

único elemento siempre se encuentra ordenado. A la salida de los procesos recursivos las partes ordenadas (subvectores) se mezclan de forma que resultan otras, de mayor longitud, también ordenadas.

EJEMPLO 14.9

Seguir la estrategia del algoritmo «mergesort» para ordenar la lista:

9 1 3 5 10 4 6

Se representa el proceso con las siguientes figuras en las que aparecen las divisiones.

9 1 3 5 10 4 6

9135 10 4 6

9 1 3 5 10 4 6

9 1 3 5 10 4

La mezcla comienza con las sublistas de un solo elemento, que dan lugar a otra sublista del doble de elementos

ordenados. El proceso continúa hasta que se construye un única lista ordenada. A continuación se muestra la creación

de las sublistas ordenadas:

1 3 4 5 6 9 10

1359 4 6 10

1 9 3 5 4 10

9 13 5 10 4 6

14.5.4.1. Algoritmo mergesort en JAVA

Este algoritmo de ordenación se diseña fácilmente con ayuda de las llamadas recursivas para dividir las listas en dos

mitades; posteriormente se invoca al método de mezcla de dos listas ordenadas. La delimitación de las dos listas se

puede hacer con tres índices: primero, central y último, que apuntan a los elementos del array significados por

los identificadores. Así, si se tiene una lista de 10 elementos los valores de los índices:

primero = 0; ultimo = 9; central = (primero+ultimo)/2 = 4

La primera sublista comprende los elementos a0 .. a4 y la segunda los elementos siguientes a4+1 .. a9. Los

pasos del algoritmo mergesort para el array (arreglo) a:

Recursividad 547

procedimiento mergesort(E/S arr: a, E entero: primero, ultimo)

inicio

Si primero < ultimo entonces

central ← (primero+ultimo) div 2

mergesort(a, primero, central)

// ordena primera mitad de la lista

mergesort(a, central+1, ultimo)

// ordena segunda mitad de la lista

mezcla(a, primero, central, ultimo)

{fusiona las dos sublistas ordenadas, delimitadas por

los extremos}

fin_si

fin_procedimiento

La codificación en Java consta del método mergesort() y del método auxiliar mezcla().

public class PruebaMS

{

public void mergesort(double[] a, int primero, int ultimo)

{

int central;

if (primero < ultimo)

{

central = (primero+ultimo)/2;

// división entera puesto que los operandos son enteros

mergesort(a, primero, central);

mergesort(a, central+1, ultimo);

mezcla(a, primero, central, ultimo);

}

}

private void mezcla(double[] a, int izda, int medio, int drcha)

{

double [] tmp = new double[a.length];

int x, y, z;

x = z = izda;

y = medio+1;

// bucle para la mezcla, utiliza tmp[] como array auxiliar

while (x<=medio && y<=drcha)

{

if (a[x] <= a[y])

tmp[z++] = a[x++];

else

tmp[z++] = a[y++];

}

// bucle para mover elementos que quedan de sublistas

while (x <= medio)

tmp[z++] = a[x++];

while (y <= drcha)

tmp[z++] = a[y++];

// Copia de elementos de tmp[] al array a[]

System.arraycopy(tmp, izda, a, izda, drcha-izda+1);

}

548 Fundamentos de programación

CONCEPTOS CLAVE

• Clases de recursividad: directa e

indirecta

• Concepto de recursividad.

• Complejidad de los métodos de

ordenación.

• Eficiencia en cuanto al tiempo de

ejecución

• Iteración versus recursión.

• Notación O.

• Requisitos de un algoritmo

recursivo.

RESUMEN

Un subprograma se dice que es recursivo si tiene una o más

sentencias que son llamadas a sí mismo. La recursividad

puede ser directa e indirecta, la recursividad indirecta ocurre cuando el subprograma —método, procedimiento o función— f() llama a p() y éste a su vez llama a f(). La

recursividad es una alternativa a la iteración en la resolución

de algunos problemas matemáticos. Los aspectos más importantes a tener en cuenta en el diseño y construcción de

métodos recursivos son los siguientes:

• Un algoritmo recursivo correspondiente con un método normalmente contiene dos tipos de casos: uno o

más casos que incluyen al menos una llamada recursiva y uno o más casos de terminación o parada del

problema en los que éste se soluciona sin ninguna

llamada recursiva sino con una sentencia simple. De

otro modo, un método recursivo debe tener dos partes:

una parte de terminación en la que se deja de hacer

llamadas, es el caso base, y una llamada recursiva con

sus propios parámetros.

• Muchos problemas tienen naturaleza recursiva y la

solución más fácil es mediante un método recursivo.

De igual modo, aquellos problemas que no entrañen

una solución recursiva se deberán seguir resolviendo

mediante algoritmos iterativos.

• Todo algoritmo recursivo puede ser transformado en

otro de tipo iterativo, pero para ello a veces se nece-

sita utilizar pilas donde almacenar los cálculos parciales.

• Los métodos con llamadas recursivas utilizan memoria extra en las llamadas; existe un límite en las

llamadas, que depende de la memoria de la computadora. En caso de superar este límite ocurre un error de

overflow.

• Cuando se codifica un método recursivo se debe comprobar siempre que tiene una condición de terminación; es decir, que no se producirá una recursión infinita. Durante el aprendizaje de la recursividad es usual

que se produzca ese error.

• Para asegurarse de que el diseño de un método recursivo es correcto se deben cumplir las siguientes tres

condiciones:

1. No existe recursión infinita. Una llamada recursiva

puede conducir a otra llamada recursiva y ésta conducir a otra, y así sucesivamente; pero cada llamada debe de aproximarse más a la condición de

terminación.

2. Para la condición de terminación, el método devuelve el valor correcto para ese caso.

3. En los casos que implican llamadas recursivas: si

cada uno de los métodos devuelve un valor correcto, entonces el valor final devuelto por el método

es el valor correcto.

public static void main(String[] args)

{

PruebaMS up=new PruebaMS();

double[] a = {9,1,3,5,10,4,6};

up.mergesort(a, 0, a.length-1);

for (int i = 0; i < a.length; i++)

System.out.println(a[i]);

}

}

Recursividad 549

EJERCICIOS

14.1. La suma de una serie de números consecutivos de 1

se puede definir recursivamente como:

suma(1) = 1

suma(n) = n + suma(n-1)

Escribir la función recursiva que acepte n como un

argumento y calcule la suma de los números de 1 a n.

14.2. El valor de xn se puede definir recursivamente

como:

x0

= 1

xn

= x * xn – 1

Escribir una fu nción recursiva que calcule y devuelva el valor de xn

.

14.3. Reescribir la función escrita en el Ejercicio 14.2 de

modo que se utilice un algoritmo repetitivo para calcular el valor de xn

.

14.4. Convierta la siguiente función iterativa en una recursiva. La función calcula un valor aproximado de e, la

base de los logaritmos naturales, sumando las series

1 + 1/1! + 1/2! + ... + 1/n!

hasta que los términos adicionales no afecten a la

aproximación

real función loge()

var

// Datos locales

real: enl, delta, fact

entero: n

inicio

enl ← 1.0

fact ← 1.0

delta ← 1.0

hacer

enl ← delta

n ← n + 1

fact ← fact * n

delta ← 1.0 / fact

mientras (enl <> enl + delta)

devolver (enl)

fin_función

14.5. Explique por qué la siguiente función puede producir

un valor incorrecto cuando se ejecute:

real función factorial (E real: n)

inicio

si (n = 0 o n = 1) entonces

devolver(1)

si_no

devolver (n * factorial (n-1))

fin_si

fin_función

14.6. Proporcionar funciones recursivas que representen

los siguientes conceptos:

a) El producto de dos números naturales.

b) El conjunto de permutaciones de una lista de

números.

14.7. El elemento mayor de un array entero de n-elementos

se puede calcular recursivamente. Definir la función:

entero funcion max(E entero: x, y)

que devuelve el mayor de dos enteros x e y. Definir

la función