Sie sind auf Seite 1von 44

MANUAL DE PRCTICAS

PROGRAMACIN DE APLICACIONES CON


ESTRUCTURAS DE DATOS

INDICE DE TEMAS Y PRCTICAS


Tema del curso

Prctica

Pag.

Listas simples y dobles

Prctica I

rboles

Prctica II

11

grafos

Prctica III

18

Pilas

Prctica IV

21

colas

Prctica V

25

Ordenamientos

Practica VI

28

Contenido
INDICE DE TEMAS Y PRCTICAS ....................................................................... 1
INTRODUCCIN .................................................................................................... 3
PRACTICA I. LISTAS SIMPLES ............................................................................ 4
I.1. Objetivo .................................................................................................................................................... 4
I.2. Equipo ...................................................................................................................................................... 4
I.3. Materiales ................................................................................................................................................. 4
I.4. Descripcin .............................................................................................................................................. 4
Listas .............................................................................................................................................................. 4
I.5. Procedimiento .......................................................................................................................................... 7
I.6. Ejercicios.................................................................................................................................................. 7

PRACTICA II. ARBOLES ..................................................................................... 10


II.1. Objetivo .................................................................................................................................................10
II.2. Equipo ....................................................................................................................................................10
II.3. Materiales ..............................................................................................................................................10
II.4. Descripcin ............................................................................................................................................10
Arboles ..........................................................................................................................................................10
II.5. Procedimiento ........................................................................................................................................16
II.6. Ejercicios ...............................................................................................................................................16

PRACTICA III. GRAFOS....................................................................................... 17


III.1. Objetivo ................................................................................................................................................17
III.2. Equipo ..................................................................................................................................................17
III.3. Materiales .............................................................................................................................................17
III.4. Descripcin ...........................................................................................................................................17
Grafos ............................................................................................................................................................17
III.5. Procedimiento .......................................................................................................................................20
III.6. Ejercicios ..............................................................................................................................................20

PRACTICA IV. PILAS ........................................................................................... 20


IV.1. Objetivo ................................................................................................................................................20
IV.2. Equipo ..................................................................................................................................................20
IV.3. Materiales .............................................................................................................................................21
IV.4. Descripcin ..........................................................................................................................................21
Pilas y colas ...................................................................................................................................................21
IV.5. Procedimiento.......................................................................................................................................22
IV.6. Ejercicios ..............................................................................................................................................23

PRACTICA V. COLAS .......................................................................................... 24


V.1. Objetivo .................................................................................................................................................24
V.2. Equipo....................................................................................................................................................24
V.3. Materiales ..............................................................................................................................................24
V.4. Descripcin ............................................................................................................................................24
V.5. Procedimiento ........................................................................................................................................26
V.6. Ejercicios ...............................................................................................................................................27

PRACTICA VI. ORDENAMIENTOS ...................................................................... 27


VI.1. Objetivo ................................................................................................................................................27
VI.2. Equipo ..................................................................................................................................................27
VI.3. Materiales .............................................................................................................................................27
VI.4. Descripcin ..........................................................................................................................................27
Ordenamiento y busqueda .............................................................................................................................27
VI.5. Procedimiento.......................................................................................................................................41
VI.6. Ejercicios ..............................................................................................................................................41

FUENTES CONSULTADAS ................................................................................. 43


2

INTRODUCCIN
En este manual de prcticas se realizarn programas que usen estructuras de
datos en la solucin de diferentes problemas.
Les ser til a los estudiantes que tomen el curso de estructura de datos para
reforzar la comprensin de conceptos bsicos necesarios para poder realizar
programas en los que se apliquen las estructuras con las que esten relaicionados.
Una estructura de datos es un conjunto de datos de tipos iguales o diferentes que
se relacionan entre si y que se pueden operar como un todo.

D
a
t
o
s

Simples

Estructurados

Hacen referencia a
un nico valor a la
vez en memoria

Entero, Real, Carcter, Lgico

Se refieren a un
grupo de casillas de
memoria

Estticos
Dinmicos

Arreglos, Registros,
Archivos, Cadenas
Listas, Arboles,
Grafos

Para implementar alguna estructura de datos, primero es necesario tener muy


claro cmo va a ser el manejo de memoria, la diferencia entre estructuras
estticas y dinmicas es el manejo de memoria.
En la esttica, durante la ejecucin del programa el tamao de la estructura no
cambia.
En la dinmica, durante la ejecucin del programa el tamao de la estructura
puede cambiar.
Con las estructuras de datos dinmicas pueden implementarse aplicaciones que
tienen un nmero de elementos muy variado durante la ejecucin de la aplicacin,
las listas, rboles, grafos, pilas y colas pueden ser implementados con este tipo de
estructuras.
De igual forma los ordenamientos y busquedas son tareas necesarias en muchas
aplicaciones.

PRACTICA I. LISTAS SIMPLES


I.1. Objetivo
El alumno ser capaz de elaborar programas en los que sea necesario utilizar
listas enlazadas para la solucin de problemas.
I.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.
I.3. Materiales
Hojas de papel bond o cuaderno, lpiz o bolgrafo.
I.4. Descripcin
Listas
Una lista es una coleccin de elementos que tienen intrnseco algn orden. Por
ejemplo: lista de estudiantes, lista de pasajeros, lista de vehculos robados. En
algunos casos no significa que esta ordenando alfabticamente o
numricamente, pero si nos indica que se conoce, dado un elemento de la lista,
cual es el siguiente.
Una lista enlazada es una estructura de datos que permite almacenar informacin
dinmicamente, es decir la memoria se reserva en tiempo de corrida del
programa.
Lista

Inf. Sig.

Inf. Sig.

Inf. Sig.

Inf. Sig.
Null

Nodo

Nodo

Nodo

Nodo

Caractersticas de una lista:


o Cada elemento de la lista enlazada se denomina NODO.
o Un nodo contiene dos campos: uno de informacin (datos del estudiante,
datos del pasajero, valores, etc.) llamado inf. y otro que contiene la
direccin del siguiente nodo, llamado sig. Note que este ltimo es un
apuntador a NODO.
o Existe un apuntador externo, llamado Lista que apunta al primer nodo, a
travs del cual tenemos acceso a la lista enlazada. Este apuntador no esta
incluido en ningn nodo. Los dems apuntadores son internos de la lista.
o El ltimo nodo de la lista contiene un valor especial, llamado NULL, en el
campo siguiente, el cual representa un apuntador vaco. Esto indica el fin
de la lista.
o Si una lista no contiene nodos, se dice que es una lista vaca o nula. En
este caso el apuntador externo vale NULL.

Los elementos de una lista no necesita ser todos del mismo tipo, en el campo de
informacin se pueden almacenar diferentes tipo dependiendo de lo que se quiere
representar.
Normalmente se definen varios tipos que facilitan el manejo de las listas en C, la
declaracin de tipos puede tener una forma parecida a esta:
typedef struct _nodo {
int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
tipoNodo es el tipo para declarar nodos, pNodo es el tipo para declarar punteros a
un nodo, Lista es el tipo para declarar listas.
Como puede verse, un puntero a un nodo y una lista son la misma cosa. En
realidad, cualquier puntero a un nodo es una lista, cuyo primer elemento es el
nodo apuntado. Es muy importante que nuestro programa nunca pierda el valor
del puntero al primer elemento, ya que si no existe ninguna copia de ese valor, y
se pierde, ser imposible acceder al nodo y no podremos liberar el espacio de
memoria que ocupa.
Operaciones bsicas:
o Aadir o insertar elementos.
o Buscar o localizar elementos.
o Borrar elementos.
o Moverse a travs de una lista, anterior, siguiente, primero.
Cada una de estas operaciones tendr varios casos especiales, por ejemplo, no
ser lo mismo insertar un nodo en una lista vaca, o al principio de una lista no
vaca, o la final, o en una posicin intermedia.
Insertar un elemento en una lista vaca:
El caso ms sencillo. Partiremos de que ya tenemos el nodo a insertar y, por
supuesto un puntero que apunte a l, adems el puntero a la lista valdr NULL:

El proceso es muy simple:


nodo->siguiente apunte a NULL.
Lista apunte a nodo.

Insertar un elemento en la primera posicin de una lista:


Partiremos de un nodo a insertar, con un puntero que apunte a l, y de una lista,
con elementos:

El proceso sigue siendo muy sencillo:


Hacemos que nodo->siguiente apunte a Lista.
Hacemos que Lista apunte a nodo.

Insertar un elemento en la ltima posicin de una lista:


Partiremos de una lista no vaca:

El proceso en este caso tampoco es excesivamente complicado:


o Necesitamos un puntero que seale al ltimo elemento de la lista. La
manera de conseguirlo es empezar por el primero y avanzar hasta que el
nodo que tenga como siguiente el valor NULL.
o Hacer que nodo->siguiente sea NULL.
o Hacer que ultimo->siguiente sea nodo.

Insertar un elemento a continuacin de un nodo cualquiera de una lista:


De nuevo podemos considerar el caso anterior como un caso particular de este.
Ahora el nodo "anterior" ser aquel a continuacin del cual insertaremos el nuevo
nodo:

Suponemos que ya disponemos del nuevo nodo a insertar, apuntado por nodo, y
un puntero al nodo a continuacin del que lo insertaremos.
El proceso a seguir ser:
Hacer que nodo->siguiente seale a anterior->siguiente.
6

Hacer que anterior->siguiente seale a nodo.

I.5. Procedimiento
1. En la seccin 1.6 (seccin de ejercicios) se describen una serie de
problemas en los que es necesario aplicar los algoritmos de las listas
ligadas para hacer el programa de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
4. Compilar el programa y probarlo con todos los diferentes casos que
pueden darse en cada uno de ellos.

I.6. Ejercicios
1. Defina listas para almacenar polinomios, de tal manera que en cada nodo tenga
un campo que represente el valor del coeficiente y otro la potencia de la
variable. Codifique en C un extracto de cdigo que dados dos polinomios
almacenados en esta forma sea capaz de realizar la suma de polinomios y
almacenar en una tercera lista el polinomio resultado. Ejemplo:
Entrada:
Polinomio 1 = x5 + 5x3 + 6x2 + 1
Almacenado en lista 1 sera
1

Polinomio 2 = 2x5 + 3x4 + x2 + 3x


La lista 2 seria
2

Salida:
el polinomio resultado de la suma = 3x5 + 3x4 + 5x3 + 7x2 + 3x + 1
2. Hay muchas aplicaciones en las que se debe almacenar en la memoria un
vector de grandes dimensiones. Si la mayora de los elementos del vector son
ceros, ste puede representarse ms eficientemente utilizando una lista
enlazada con punteros, en la que cada nodo es un registro con tres campos: el
7

dato en esa posicin si es distinto de cero, el ndice de esa posicin un puntero


al siguiente nodo. Por ejemplo, para un vector de longitud 7 la lista:

Representa el vector (25, 0, 0, 0, 14, 0, 0). Dado un tipo TVector de longitud


constante Dim elaborar un programa para:
a) Calcular su Producto_Escalar, pasndole como entrada v1 y v2 de tipo
TVector.
b) Insertar un valor teniendo en cuenta que si ya existe, se debe eliminar el
valor anterior. Si la posicin est fuera de rango, no har nada. Y si es
cero el valor a insertar no deber quedar guardado en la lista ningn
nodo de ndice cero.
c) Obtener el valor en una determinada posicin del vector.
d) Mejorar los apartados anteriores redefiniendo el tipo TVector como un
registro de dos campos, uno de ellos contendr el vector en el formato
anterior y el otro indicar la longitud, la cual ya no ser necesariamente
constante.
3. Una tienda de artculos deportivos desea almacenar en una lista enlazada, con
un nico elemento por producto, la siguiente informacin (contenida en un
archivo) sobre las ventas realizadas: cdigo de artculo, cantidad y precio.
Hacer un programa que permita la creacin de la lista y su actualizacin al
realizarse nuevas ventas o devoluciones de un determinado producto.
En el registro de la venta si el producto no esta aun en la lista se crea un nodo
para insertar la informacin respectivas del producto a la lista, si el producto ya
esta registrado en la lista se actualizar el campo de cantidad de acuerdo a los
productos vendidos.
Con las devoluciones se buscar el producto y se disminuir el campo cantidad
de acuerdo a el nmero de productos devueltos.
Los datos deben quedar guardados en archivo, una vez que finaliza la
operacin del programa, adems deben liberarse los espacios de memoria
ocupados por los nodos de la lista.
4. Una forma de almacenar un nmero natural de valor mayor que el permitido en
una computadora es introducir cada dgito, de tipo natural, en un nodo de una
lista enlazada. Por ejemplo, la siguiente lista representa al nmero 357:

a) Escribe un programa que tome como parmetro un puntero a una lista


enlazada que represente un nmero de la forma indicada y devuelva el
nmero correspondiente en una variable de tipo natural.
b) Disea tambin un programa que lea por teclado una sucesin de
dgitos, de tipo carcter, y los introduzca como dgitos de tipo natural en
una lista enlazada.
Disea dos programas que realicen, respectivamente, la suma y producto de
nmeros representados de esta forma.

5. Dada la siguiente definicin de un tipo de datos en C:


typedef struct nodo{
int informacion;
struct nodo *siguiente;
}TNodo;
Se pide: Codificar una funcin en C que teniendo el siguiente prototipo:
TNodo *Concatenar ( TNodo *Lista1, TNodo *Lista2);
Reciba como parmetros dos listas del tipo definido y devuelva como resultado
una nueva lista que est formada por los elementos de las dos listas de entrada
concatenados, es decir, los elementos de la Lista1 delante de los elementos de
la Lista2. Las listas de entrada no debern ser modificadas dentro de la funcin.
Por ejemplo, si se pasan como parmetros dos listas como las mostradas en la
siguiente figura:

Se devolver una lista como la mostrada en la siguiente figura:

Para la realizacin de esta funcin se supone ya codificada en la aplicacin una


funcin cuyo prototipo es:
void InsertarAlFinal (TNodo *&lista, TNodo *elemento);

6. Realizar un men que permita manejar los siguientes datos de alumnos en una
lista ligada (Matrcula, Nombre, Promedio), las opciones del men incluyen:
1.- Insertar al inicio.
2.- Eliminar elemento inicial.
3.- Mostrar lista.
4.- Sacar promedios.
5.- Salir
Cuando se de la opcin salir, deben liberarse los espacios de memoria
ocupados por los nodos de la lista.

PRACTICA II. ARBOLES


II.1. Objetivo
El alumno ser capaz de elaborar programas que den solucin a problemas en
los que se requiere el uso de rboles.
II.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.
II.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.
II.4. Descripcin
Arboles
En su definicin recursiva un rbol es un conjunto de nodos que:
Es vaco, o bien,
Tiene un nodo raz del que descienden cero o ms subrboles.
Terminologa:
Nodos: conjunto finito de elementos.
Ramas: conjunto finito de lneas dirigidas, que conectan nodos.

10

Grado del Nodo: nmero de ramas descendentes con un nodo.


Orden: es el nmero potencial de hijos que puede tener cada elemento de
rbol. De este modo, diremos que un rbol en el que cada nodo puede
apuntar a otros dos es de orden dos, si puede apuntar a tres ser de orden
tres, etc.
Raz: primer nodo de un rbol no vaco.
Camino: secuencia de nodos en los que cada nodo es adyacente al
siguiente.
o Solo existe un camino entre la Raz y un Nodo cualquier.
o La distancia de un Nodo a la Raz determina la rapidez de bsqueda.
Padre: tiene nodos sucesores.
Hijos: Son los nodos sucesores.
Descendientes: Hijos de los hijos
Ascendientes: los padre y abuelos de un nodo hijo.
Hermanos: 2 o mas nodos del mismo padre.
Hojas: nodo sin hijos .
Nivel de un nodo: distancia a la raz.
Altura o profundidad de un rbol: nivel de la hoja del camino ms largo
desde la raz ms uno.
o La altura de un rbol vaco es 0.
Subrbol: cualquier estructura conectada por debajo del raz. C/nodo de un
rbol es la raz de un subrbol que se define por el nodo y todos los
descendientes del nodo.

A
B
D

C
E

Raiz=A
Nodos: A, B, C, D.
Ramas(A, B); (A, C), (C, F)...
Grado de la A= G(A)=2, G(D)=0; G(C)=1
Padres: A; B y C.
Hijos: De A( B y C), de B (D y E)
Descendentes de B: D y E
Ascendientes de E: B y A.
Hermano: {B, C}, {F, G}, {D, E}
Hojas: D, E, F, G
Altura del rbol: 3
Altura del Subrbol de B: 2

rbol binario
o rbol donde ningn nodo puede tener mas de 2 subrboles, en cualquier nivel
n, solo puede contener de 1 a 2n+11 nodos.

11

o rbol Completo: de Altura n es un rbol en el que para c/nivel, del 0 al n1,


est lleno de nodos. Todos los nodos hoja a nivel n ocupan posiciones a la
izquierda.
o rbol Lleno: tiene el mximo nmero de entradas para su altura: 2n. A Nivel
k, tendr 2k+11 nodos. (Nivel = Profundidad1)
o Lleno de Profundidad 3 = Nivel 2 => 22+11 nodos= 231= 7 nodos

rbol binario de busqueda


o rboles de orden 2 en los que se cumple que para cada nodo, el valor de la
clave de la raz del subrbol izquierdo es menor que el valor de la clave del
nodo y que el valor de la clave raz del subrbol derecho es mayor que el valor
de la clave del nodo.

Operaciones en rboles binarios


o Buscar un elemento.
o Insertar un elemento.
o Borrar un elemento.
o Movimientos a travs del rbol:
o Izquierda.
o Derecha.
o Raiz.
o Informacin:
o Comprobar si un rbol est vaco.
o Calcular el nmero de nodos.
o Comprobar si el nodo es hoja.
o Calcular la altura de un nodo.
o Calcular la altura de un rbol.
Buscar un elemento
Partiendo siempre del nodo raz, el modo de buscar un elemento se define de
forma recursiva.
12

o Si el rbol est vaco, terminamos la bsqueda: el elemento no est en el


rbol.
o Si el valor del nodo raz es igual que el del elemento que buscamos,
terminamos la bsqueda con xito.
o Si el valor del nodo raz es mayor que el elemento que buscamos,
continuaremos la bsqueda en el rbol izquierdo.
o Si el valor del nodo raz es menor que el elemento que buscamos,
continuaremos la bsqueda en el rbol derecho.
o El valor de retorno de una funcin de bsqueda en un ABB puede ser un
puntero al nodo encontrado, o NULL, si no se ha encontrado.
Insertar un elemento
Para insertar un elemento nos basamos en el algoritmo de bsqueda. Si el
elemento est en el rbol no lo insertaremos. Si no lo est, lo insertaremos a
continuacin del ltimo nodo visitado.
Necesitamos un puntero auxiliar para conservar una referencia al padre del nodo
raz actual. El valor inicial para ese puntero es NULL.
Padre = NULL
nodo = Raiz
Bucle: mientras actual no sea un rbol vaco o hasta que se encuentre el
elemento.
Si el valor del nodo raz es mayor que el elemento que buscamos,
continuaremos la bsqueda en el rbol izquierdo: Padre=nodo, nodo=nodo>izquierdo.
Si el valor del nodo raz es menor que el elemento que buscamos,
continuaremos la bsqueda en el rbol derecho: Padre=nodo, nodo=nodo>derecho.
Si nodo no es NULL, el elemento est en el rbol, por lo tanto salimos.
Si Padre es NULL, el rbol estaba vaco, por lo tanto, el nuevo rbol slo
contendr el nuevo elemento, que ser la raz del rbol.
Si el elemento es menor que el Padre, entonces insertamos el nuevo
elemento como un nuevo rbol izquierdo de Padre.
Si el elemento es mayor que el Padre, entonces insertamos el nuevo
elemento como un nuevo rbol derecho de Padre.
Este modo de actuar asegura que el rbol sigue siendo ABB.
Borrar un nodo
Para borrar un elemento tambin nos basamos en el algoritmo de bsqueda. Si el
elemento no est en el rbol no lo podremos borrar. Si est, hay dos casos
posibles:
o Se trata de un nodo hoja: en ese caso se borrar directamente.
o Se trata de un nodo rama: en ese caso no se puede eliminar, puesto que se
perderan todos los elementos del rbol del que el nodo actual es padre. En
su lugar se busca el nodo ms a la izquierda del subrbol derecho, o el ms

13

a la derecha del subrbol izquierdo y se intercambian sus valores. A


continuacin se elimina el nodo hoja.
Se necesita un puntero auxiliar para conservar una referencia al padre del nodo
raz actual. El valor inicial para ese puntero es NULL.
Padre = NULL
o Si el rbol est vaco: el elemento no est en el rbol, por lo tanto salir sin
eliminar ningn elemento.
o (1) Si el valor del nodo raz es igual que el del elemento que se busca,
puede ser uno de los siguientes casos:
o El nodo raz es un nodo hoja:
Si 'Padre' es NULL, el nodo raz es el nico del rbol, por lo
tanto el puntero al rbol debe ser NULL.
Si raz es la rama derecha de 'Padre', hacer que esa rama
apunte a NULL.
Si raz es la rama izquierda de 'Padre', hacer que esa rama
apunte a NULL.
Eliminar el nodo y salir.
o El nodo no es un nodo hoja:
Buscar el 'nodo' ms a la izquierda del rbol derecho de raz o
el ms a la derecha del rbol izquierdo. Hay que tener en
cuenta que puede que slo exista uno de esos rboles. Al
mismo tiempo, actualizar 'Padre' para que apunte al padre de
'nodo'.
Intercambiar los elementos de los nodos raz y 'nodo'.
Borrar el nodo 'nodo'. Esto significa volver a (1), ya que puede
suceder que 'nodo' no sea un nodo hoja.
o Si el valor del nodo raz es mayor que el elemento que se busca,
continuar la bsqueda en el rbol izquierdo.
o Si el valor del nodo raz es menor que el elemento que se busca,
continuar la bsqueda en el rbol derecho.

Movimientos a travs del rbol


La estructura se referenciar siempre mediante un puntero al nodo Raiz, este
puntero no debe perderse nunca.
Para moverse a travs del rbol se usar punteros auxiliares, de modo que desde
cualquier puntero los movimientos posibles sern: moverse al nodo raz de la rama
izquierda, moverse al nodo raz de la rama derecha o moverse al nodo Raiz del
rbol.

14

Informacin
Hay varios parmetros que se pueden calcular o medir dentro de un rbol.
Algunos de ellos nos darn idea de lo eficientemente que est organizado o el
modo en que funciona.
Comprobar si un rbol est vaco.
Un rbol est vaco si su raz es NULL.
Calcular el nmero de nodos.
Hay dos opciones para hacer esto, una es llevar siempre la cuenta de nodos en el
rbol al mismo tiempo que se aaden o eliminan elementos. La otra es contarlos,
para contar los nodos se puede recurrir a cualquiera de los tres modos de recorrer
el rbol: inorden, preorden o postorden, e incrementar el contador como accin.
Comprobar si el nodo es hoja.
Comprobar si tanto el rbol izquierdo como el derecho estn vacos. Si ambos lo
estn, se trata de un nodo hoja.
Calcular la altura de un nodo.
No hay un modo directo de hacer esto, ya que no es posible recorrer el rbol en la
direccin de la raz. De modo que hay que recurrir a otra tcnica para calcular la
altura.
Buscar el elemento del nodo de que se quiere averiguar la altura. Cada vez que se
avance un nodo incrementar la variable que contendr la altura del nodo.
o Empezar con el nodo raz apuntando a Raiz, y la 'Altura' igual a cero.
o Si el valor del nodo raz es igual que el del elemento que se busca, terminar
la bsqueda y el valor de la altura es 'Altura'.
o Incrementar 'Altura'.
o Si el valor del nodo raz es mayor que el elemento que se busca, continuar
la bsqueda en el rbol izquierdo.
o Si el valor del nodo raz es menor que el elemento que se busca, continuar
la bsqueda en el rbol derecho.
Calcular la altura de un rbol.
La altura del rbol es la altura del nodo de mayor altura. Para buscar este valor se
tiene que recorrer todo el rbol, de nuevo es indiferente el tipo de recorrido que se
haga, cada vez que se cambie de nivel incrementar la variable que contiene la
altura del nodo actual, cuando se llega a un nodo hoja comparar su altura con la
variable que contiene la altura del rbol si es mayor, actualizar la altura del rbol.
o Iniciar un recorrido del rbol en postorden, con la variable de altura igual a
cero.
o Cada vez que se empieze a recorrer una nueva rama, incrementar la altura
para ese nodo.

15

o Despus de procesar las dos ramas, verificar si la altura del nodo es mayor
que la variable que almacena la altura actual del rbol, si es as, actualizar
esa variable.
II.5. Procedimiento
1. En la seccin de ejercicios se describen una serie de problemas en los
que es necesario aplicar los algoritmos de rboles para hacer el
programa de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
4. Compilar el programa y probarlo con todos los diferentes casos que
pueden darse en cada uno de ellos.

II.6. Ejercicios
1. Disear y escribir un programa que retorne la altura (mxima longitud de los
caminos de la raz hasta cada hoja) de un rbol.
2. Escribir un programa que permita almacenar palabras en un rbol que contiene
una letra por vrtice.
o La raz representa el inicio de la palabra.
o Las ramas son para la letras intermedias.
o Cada hoja se marca con un carcter especial que marca el final de
cada palabra
Carta
Casa
Casado
Pepe
Perro

La implementacin de este rbol debe tener las siguientes operaciones:


buscar una palabra en el rbol para saber si est o no
aadir una palabra si no est
mostrar todas las palabras del rbol

3. Implementar una estructura de datos que sirva como contador de cada palabra
diferente que aparece en un texto.

16

o El texto se leer desde el teclado.


o Se mostrarn todas las palabras con sus frecuencias, ordenadas por
orden alfabtico, o por el orden de su frecuencia de aparicin en el
texto.
5. Implementar un men que permita manejar las operaciones de insertar,
eliminar, recorridos y contar elementos del rbol.
6. Escribir un programa que calcule la distancia entre dos nodos hermanos de un
rbol, cuyos valores se pasan al mtodo mediante parmetros, a y b, estando b
a la derecha de a. La distancia es la cantidad de hermanos situados entre
ambos, ms uno. Si el nodo a no est en el rbol, se lanzar NoExiste. Si el
nodo b no se encuentra entre los hermanos situados a la derecha de a se
lanzar NoSonHermanos.

PRACTICA III. GRAFOS


III.1. Objetivo
El alumno ser capaz de elaborar programas que den solucin a problemas en
los que se requiere el uso de grafos.
III.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.
III.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.
III.4. Descripcin
Grafos
Un grafo simple G = (N, A) consiste de N, un conjunto no vaco de nodos, y A, un
conjunto de pares no ordenados de elementos distintos de N llamados arcos.
Grafo dirigido G = (N, A) los arcos son pares ordenados de (no necesariamente
distintos) nodos.
Un grafo es un objeto matemtico que se utiliza para representar circuitos, redes,
etc. Los grafos son muy utilizados en computacin, ya que permiten resolver
problemas muy complejos.
Dos nodos, u y v en un grafo no-dirigido G son llamados adyacentes (o vecinos)
en G, si {u, v} es un arco de G.

17

El grado de un nodo en un grafo no dirigido es el nmero de arcos incidentes a l,


excepto que un loop en un nodo contribuye dos veces al grado de este nodo.

Grado (d) = 1
Grado (e) = 0 (nodo isolado)
Grado (b) = 6

El grafo completo de n nodos, denotado por Kn, es el grafo simple que contiene
exactamente un arco entre cada par de nodos distintos.

K2

K4
K3

K5

K6

18

Un grafo simple G = (V, E) con n nodos puede ser representado por su matriz de
adyacencia, A, donde la entrada aij en fila i y columna j es:
o 1 si {vi ,vj } es un arco de ai j
o 0 en otro caso.

c
b
f

d
DE

Sea G=(N,A) un grafo no dirigido. Suponga que v1,v2,vn son los nodos y
e1,e2,,em son los arcos de G. La matriz de incidencia con respecto a este
ordenamiento de N y A es la matriz de nxm M=[mij]
= 1 cuando el arco ej es incidente a vi . mij
=0 en otro caso.

c
e2

e3
e8

b
e7

e9

f
E10

e1
e6

d
e4

DE e1

e2

e3

e4

e5

e6

e7 e8 e9 e10

e
e5

19

III.5. Procedimiento
1. En la seccin de ejercicios se describen una serie de problemas en los
que es necesario aplicar los algoritmos de grafos para hacer el
programa de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
4. Compilar el programa y probarlo con todos los diferentes casos que
pueden darse en cada uno de ellos.

III.6. Ejercicios
1. Realizar una aplicacin de interfaz Grafo simple matriz de adyacencia, que
permita representar grficamente un grafo simple y su correspondiente matriz
de adyacencia, permitiendo una serie de operaciones como por ejemplo mover
los vrtices a las posiciones que queramos, aadir o borrar tanto vrtices como
arcos, permutar vrtices, agrupar todos los vrtices en el mismo punto o
agrupar todos los vrtices circularmente. Que contenga dos ventanas, una
correspondiente al grafo y otra correspondiente a la matriz, los cambios que se
hagan en una ventana deben reflejarse en la otra (ya que estamos manejando
el mismo grafo aunque representado de dos formas distintas).
2. Realizar una aplicacin de interfaz Grafo simple matriz de incidencia, que
permita representar grficamente un grafo simple y su correspondiente matriz
de incidencia, permitiendo una serie de operaciones como por ejemplo mover
los vrtices a las posiciones que queramos, aadir o borrar tanto vrtices como
arcos, permutar vrtices, agrupar todos los vrtices en el mismo punto o
agrupar todos los vrtices circularmente. Que contenga dos ventanas, una
correspondiente al grafo y otra correspondiente a la matriz, los cambios que se
hagan en una ventana deben reflejarse en la otra (ya que estamos manejando
el mismo grafo aunque representado de dos formas distintas).

PRACTICA IV. PILAS


IV.1. Objetivo
El alumno ser capaz de elaborar aplicacones computacionales que den
solucin a problemas en los que se requiere el uso de las estructuras de datos
pilas.
IV.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.

20

IV.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.

IV.4. Descripcin
Pilas y colas

Sale

Entra

La estructura de datos PILA


Su nombre se deriva de la metfora de una pila de
platos en una cocina.

Tope

La insercin y extraccin de elementos de la pila


siguen el principio LIFO (last-in-first-out).
El ltimo elemento en entrar es el nico accesible
en cada momento.

Las operaciones bsicas de una pila son push (empujar, meter) y pop (sacar)
Push: aade un nuevo elemento a la pila
Pop: elimina un elemento de la pila
Otras operaciones usualmente incluidas en el tipo de dato abstracto pila son:
isEmpty (estVacia): verifica si la pila est vaca
isFull (estLlena): verifica si la pila est llena

4
push(4)

1
4
push(1)

1
1
4
push(1)

1
4
pop()

4
1
4
push(4)

1
4
pop()

Implementacin con arreglos


En C, los arreglos permiten almacenar colecciones ordenadas.
La desventaja de implementar una pila mediante un arreglo es que esta ltima es
de tamao fijo, mientras que la pila es de tamao dinmico.
#define STACKSIZE 100
struct Stack{
int top;
int nodes[STACKSIZE];
};

21

struct Stack *create_stack


(struct Stack *ps) {
ps = (struct Stack *)
malloc(sizeof(struct Stack));
ps->top=-1;
return ps;
}
main(){
struct Stack *ps;
ps=create_stack(ps);
:
}

Las operaciones bsicas


PUSH
void push(struct Stack* ps, int i) {
if (ps->top == (STACKSIZE -1))
printf(Full stack\n");
else {
ps->top++;
ps->nodes[ps->top] = i;
}
}

POP
int pop(struct Stack *ps) {
if (ps->top== -1)
printf(Empty stack\n");
else {
int t= ps->nodes[ps-> top];
ps->top--;
return t;
}
}

Aplicaciones de las pilas


Navegador Web
Se almacenan los sitios previamente visitados
Cuando el usuario quiere regresar (presiona el botn de retroceso), simplemente
se extrae la ltima direccin (pop) de la pila de sitios visitados.
Editores de texto
Los cambios efectuados se almacenan en una pila
Usualmente implementada como arreglo
Usuario puede deshacer los cambios mediante la operacin undo, la cual
extraer el estado del texto antes del ltimo cambio realizado.
IV.5. Procedimiento
1. En la seccin de ejercicios se describen una serie de problemas en los
que es necesario aplicar los algoritmos de pilas, para hacer el programa
de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
4. Compilar el programa y probarlo con todos los diferentes casos que
pueden darse en cada uno de ellos.

22

IV.6. Ejercicios
1. Se pretende realizar un programa de una calculadora con la notacin polaca
inversa (RPN) en lugar de la infija. La calculadora deber aceptar los
operadores de suma, resta, multiplicacin y divisin (+, -, * y /) y slo manejar
operandos de tipo entero.
En la notacin RPN, cada operador sigue a sus operandos; una expresin infija
como: (7 - 3) * (2 + 1)
En notacin RPN se introduce como: 7 3 2 1 + *
La ventaja de este tipo de notacin es que hace innecesaria la utilizacin de
parntesis. La notacin no es ambigua mientras se sepa cuntos operandos
espera cada operador.
El programa usar una pila para almacenar los operandos, y se realiza de la
siguiente forma:
o La estructura del programa es un bucle que va leyendo hasta que se
introduce el carcter f para terminar el bucle, y realiza las
operaciones adecuadas para cada operando u operador.
o
o Cuando se lee un operador, se extraen dos operandos (puesto que
todos los operadores son binarios), se aplica el operador y el
resultado se vuelve a introducir en la pila.
o Los elementos se van a almacenar en una tabla de enteros de
tamao MAXELE (es una constante que vale 10) de nombre pila. Se
empieza a llenar por el primer elemento
o (posicin 0 de la tabla). La variable cima es de tipo int y contiene el
ndice dentro de la tabla donde se puede almacenar el prximo
elemento. El ndice del ltimo elemento almacenado ser cima-1, y el
valor inicial de cima ser 0.
2. Una secuencia de caracteres con parntesis equilibrados es aquella en la que
Cada parntesis de apertura tiene otro de cierre, y
Los caracteres entre ambos son tambin una secuencia con parntesis
equilibrados
Escribir un programa capaz de determinar si la secuencia est o no equilibrada
Los parntesis considerados son: () [] {} <>
Se permite el anidamiento ([{}]) pero no el solapamiento ([)]
El resto de caracteres en la secuencia se ignora
Si hay un error se pone un mensaje explicativo en pantalla
3. Escribir un programa que permita fusionar los elementos de dos pilas creando
una tercera. La pila resultante debe contener alternativamente un elemento de
la primera lista, uno de la segunda, uno de la primera, uno de la segunda, etc,
hasta que se acabe una de las dos; luego aparecern los elementos restantes
de la lista ms larga.

23

PRACTICA V. COLAS
V.1. Objetivo
El alumno ser capaz de elaborar aplicacones computacionales que den
solucin a problemas en los que se requiere el uso de las estructuras de datos
colas.
V.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.
V.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.

V.4. Descripcin
La estructura de datos COLA

Su nombre se deriva de la metfora de una cola de personas en una


taquilla.
Entra
La insercin y extraccin de elementos de la cola siguen cola
el principio FIFO (first-in-first-out).
El elemento con ms tiempo en la cola es el que puede
ser extrado.
frente
Sale
Operaciones de una COLA
Las operaciones bsicas de una cola son enqueue (meter) y dequeue (sacar)
enqueue: aade un nuevo elemento a final de la cola
dequeue: elimina (saca) el primer elemento de la cola
Otras operaciones usualmente incluidas en el tipo abstracto COLA son:
isEmpty (estVacia): verifica si la cola est vaca
isFull (estLlena): verifica si la cola est llena

Ejemplo

24

No es necesario mover
todos los elementos

Implementacin con arreglos


Una cola es una coleccin ordenada de objetos.
En C, los arreglos permiten almacenar colecciones ordenadas.
Misma desventaja: los arreglos tienen tamao fijo.
Uso eficiente mediante un arreglo circular.
#define QUEUESIZE 100
struct Queue{
int front;
int rear;
int nodes[QUEUESIZE];
};
struct Queue *create_queuek
(struct Queue *ps) {
ps = (struct Queue *)
malloc(sizeof(struct Queue));
ps->front = 0;
ps->rear = -1;
return ps;
}
main(){
struct Queue *ps;
ps=create_queue(ps);
:
}

25

Las operaciones bsicas


ENQUEUE
void enqueue(struct Queue* ps,
int i) {
if (ps->rear == (QUEUESIZE -1))
printf(Full queue\n");
else {
ps->rear++;
ps->nodes[ps->rear] = i;
}
}

DEQUEUE
int dequeue (struct Queue *ps) {
if (ps->front == ps->rear + 1)
printf(Empty stack\n");
else {
int t= ps->nodes[ps-> front];
ps->front++;
return t;
}
}

a b c d e f

Colas circulares
El objetivo de una cola circular es aprovechar al frente
mximo el espacio del arreglo.

La implementacin tradicional considera dejar un


espacio entre el frente y la cola.

cola

e f

La idea es insertar elementos en las localidades


previamente desocupadas.

frente

h i

e f

g
cola

frente
Aplicaciones de las colas
En general, operaciones en redes de computadoras
Trabajos enviados a una impresora
Solicitudes a un servidor.
Clientes solicitando ser atendidos por una telefonista
Simulaciones de cualquier situacin real en la que se presente una organizacin
tipo cola.
V.5. Procedimiento
1. En la seccin de ejercicios se describen una serie de problemas en los
que es necesario aplicar los algoritmos de pilas, colas o ambos, para
hacer el programa de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
4. Compilar el programa y probarlo con todos los diferentes casos que
pueden darse en cada uno de ellos.

26

V.6. Ejercicios
1. Escribir un programa que realice la simulacin del comportamiento de la cola en
una caja de cobro de un cine, mediante numeros aleatorios que tomen valores
de 1 a 5, determinar el nmero de personas que llegan y del mismo modo
determinar el nmero de minutos que se tarda el empleado de mostrador en
atender a una persona.
2. Realizar un programa Escribir un programa que permita fusionar los elementos
de dos pilas creando una tercera. La pila resultante debe contener
alternativamente un elemento de la primera lista, uno de la segunda, uno de la
primera, uno de la segunda, etc, hasta que se acabe una de las dos; luego
aparecern los elementos restantes de la lista ms larga.

PRACTICA VI. ORDENAMIENTOS


VI.1. Objetivo
El alumno ser capaz de elaborar programas que den solucin a problemas
implementando algoritmos de ordenamiento y/o bsqueda adecuados en ellos.
VI.2. Equipo
Computadora personal, dispositivo de almacenamiento secundario (disquete,
memoria USB, etc.), lenguaje de programacin pascal, c, java, etc.
VI.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.
VI.4. Descripcin
Ordenamiento y busqueda
Debido a que las estructuras de datos son utilizadas para almacenar informacin,
para poder recuperar esa informacin de manera eficiente es deseable que
aquella est ordenada. Existen varios mtodos para ordenar las diferentes
estructuras de datos bsicas.
En general los mtodos de ordenamiento no son utilizados con frecuencia, en
algunos casos slo una vez. Hay mtodos muy simples de implementar que son
tiles en los casos en dnde el nmero de elementos a ordenar no es muy grande
(ej, menos de 500 elementos). Por otro lado hay mtodos sofisticados, ms
difciles de implementar pero que son ms eficientes en cuestin de tiempo de
ejecucin.
Los mtodos sencillos por lo general requieren de aproximadamente n x n pasos
para ordenar n elementos.
Los mtodos simples son: insertion sort, selection sort, bubble sort, y shellsort (es

27

una extensin al insertion sort), es ms rpido. Los mtodos ms complejos son el


quick-sort, el heap sort, radix y address-calculation sort. El ordenar un grupo de
datos significa mover los datos o sus referencias para que queden en una
secuencia tal que represente un orden, el cual puede ser numrico, alfabtico o
incluso alfanumrico, ascendente o descendente.
Insertion Sort
Este es uno de los mtodos ms sencillos. Se toman uno por uno los elementos
de un arreglo y recorrerlo hacia su posicin con respecto a los anteriormente
ordenados. As empieza con el segundo elemento y lo ordena con respecto al
primero. Luego sigue con el tercero y lo coloca en su posicin ordenada con
respecto a los dos anteriores, as sucesivamente hasta recorrer todas las
posiciones del arreglo.
Este es el algoritmo, procedimiento Insertion Sort:
Este procedimiento recibe el arreglo de datos a ordenar a[] y altera las posiciones
de sus elementos hasta dejarlos ordenados de menor a mayor. N representa el
nmero de elementos que contiene a[].
paso 1: [Para cada pos. del arreglo]
For i <- 2 to N do
paso 2: [Inicializa v y j]
v <- a[i]
j <- i.
paso 3: [Compara v con los anteriores]
While a[j-1] > v AND j>1 do
paso 4: [Recorre los datos mayores]
Set a[j] <- a[j-1],
paso 5: [Decrementa j]
set j <- j-1.
paso 5: [Inserta v en su posicin]
Set a[j] <- v.
paso 6: [Fin]
End.
Ejemplo:
Arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e'],
el algoritmo va a recorrer el arreglo de izquierda a derecha. Primero toma el
segundo dato 's' y lo asigna a v y i toma el valor de la posicin actual de v.
Luego compara esta 's' con lo que hay en la posicin j-1, es decir, con 'a'. Debido
a que 's' no es menor que 'a' no sucede nada y avanza i.
Ahora v toma el valor 'o' y lo compara con 's', como es menor recorre a la 's' a la
posicin de la 'o'; decrementa j, la cual ahora tiene la posicin en dnde estaba la
's'; compara a 'o' con a[j-1] , es decir, con 'a'. Como no es menor que la 'a' sale del
for y pone la 'o' en la posicin a[j]. El resultado hasta este punto es el arreglo
siguiente: a = ['a','o','s','r',....]
As se contina y el resultado final es el arreglo ordenado :
a = ['a','a','e','e','g','i','l','m','n','o','p','r','s','t','x']

Selection Sort

28

Consiste en encontrar el menor de todos los elementos del arreglo e


intercambiarlo con el que est en la primera posicin. Luego el segundo mas
pequeo, y as sucesivamente hasta ordenar todo el arreglo.
Procedimiento Selection Sort
paso 1: [Para cada pos. del arreglo]
For i <- 1 to N do
paso 2: [Inicializa la pos. del menor]
menor <- i
paso 3: [Recorre todo el arreglo]
For j <- i+1 to N do
paso 4: [Si a[j] es menor]
If a[j] < a[menor] then
paso 5: [Reasigna el apuntador al menor]
min = j
paso 6: [Intercambia los datos de la pos.
min y posicin i]
Swap(a, min, j).
paso 7: [Fin]
End.

Ejemplo:
El arreglo a ordenar es a = ['a','s','o','r','t','i','n','g','e','x','a','m','p','l','e']. Se empieza
por recorrer el arreglo hasta encontrar el menor elemento. En este caso el menor
elemento es la primera 'a'. De manera que no ocurre ningn cambio. Luego se
procede a buscar el siguiente elemento y se encuentra la segunda 'a'. Esta se
intercambia con el dato que est en la segunta posicin, la 's', quedando el arreglo
as despus de dos recorridos: a = ['a','a','o','r','t','i','n','g','e','x','s','m','p','l','e'].
El siguiente elemento, el tercero en orden de menor mayor es la primera 'e', la cual
se intercambia con lo que est en la tercera posicin, o sea, la 'o'. Le sigue la
segunda 's', la cual es intercambiada con la 'r'. El arreglo ahora se ve de la
siguiente manera: a = ['a','a','e','e','t','i','n','g','o','x','s','m','p','l','r']. De esta manera se
va buscando el elemento que debe ir en la siguiente posicin hasta ordenar todo el
arreglo.
El nmero de comparaciones que realiza este algoritmo es :
para el primer elemento se comparan n-1 datos, en general para el elemento isimo se hacen n-i comparaciones, por lo tanto, el total de comparaciones es:
la sumatoria para i de 1 a n-1 (n-i) = 1/2 n (n-1).
Shellsort
Denominado as por su desarrollador Donald Shell (1959), ordena una estructura
de una manera similar a la del Bubble Sort, sin embargo no ordena elementos
adyacentes sino que utiliza una segmentacin entre los datos. Esta segmentacin
puede ser de cualquier tamao de acuerdo a una secuencia de valores que
empiezan con un valor grande (pero menor al tamao total de la estructura) y van
disminuyendo hasta llegar al '1'. Una secuencia que se ha comprobado ser de las
mejores es: ...1093, 364, 121, 40, 13, 4, 1. En contraste, una secuencia que es
mala porque no produce un ordenamiento muy eficiente es ...64, 32, 16, 8, 4, 2, 1.
Su complejidad es de O(n1.2) en el mejor caso y de O(n1.25) en el caso promedio.

29

Algoritmo del metodo de ordenamiento es:


void shellsort ( int a[], int n) {
/* Recibe un arreglo a ordenar a[] y el tamao del arreglo n. Utiliza en este caso
una serie de t=6 incrementos h=[1,4,13,40,121,364] para el proceso (se asume
que el arreglo no es muy grande). */
int x,i,j,inc,s;
for(s=1; s < t; s++) { /* recorre el arreglo de incrementos */
inc = h[s];
for(i=inc+1; i < n; i++) {
x = a[i];
j = i-inc;
while( j > 0 && a[j] > x) {
a[j+h] = a[j];
j = j-h;
}
a[j+h] = x;
}
}
}
Bubble Sort (ordenamiento burbuja)
Funciona de la siguiente manera: Se recorre el arreglo intercambiando los
elementos adjacentes que estn desordenados. Se recorre el arreglo tantas veces
hasta que ya no haya cambios. Prcticamente lo que hace es tomar el elemento
mayor y lo va recorriendo de posicin en posicin hasta ponerlo en su lugar.
Procedimiento Bubble Sort
paso 1: [Inicializa i al final de arreglo]
For i <- N downto 1 do
paso 2: [Inicia desde la segunda pos.]
For j <- 2 to i do
paso 4: [Si a[j-1] es mayor que el que le sigue]
If a[j-1] < a[j] then
paso 5: [Los intercambia]
Swap(a, j-1, j).
paso 7: [Fin]
End.

Tiempo de ejecucin del bubble sort:


para el mejor caso (un paso) O(n)
peor caso n(n-1)/2
promedio O(n2)

Merge Sort
El mtodo Quicksort divide la estructura en dos y ordena cada mitad
recursivamente. El caso del MergeSort es el opuesto, es decir, en ste mtodo de
unen dos estructuras ordenadas para formar una sola ordenada correctamente.

30

Tiene la ventaja de que utiliza un tiempo proporcional a: n log (n), su desventaja


radica en que se requiere de un espacio extra para el procedimiento.
Este tipo de ordenamiento es til cuando se tiene una estructura ordenada y los
nuevos datos a aadir se almacenan en una estructura temporal para despus
agregarlos a la estructura original de manera que vuelva a quedar ordenada.
Procedimiento MergeSort
/*recibe el arreglo a ordenar un ndice l que indica el lmite inferior del arreglo a
ordenar y un ndice r que indica el lmite superior*/
void mergesort(int a[], int l, int r) {
int i,j,k,m,b[MAX];
if (r > l) {
m = (r+l) /2;
mergesort(a, l, m);
mergesort(a, m+1, r);
for (i= m+1; i > l;i--)
b[i-1] = a[i-1];
for (j= m; j < r;j++)
b[r+m-j] = a[j+1];
for (k=l ; k <=r; k++)
if(b[i] < b[j]) a[k] = b[i++];
else
a[k] = b[j--];
}
}
a = {a,s,o,r,t,i,n,g,e,x,a,m,p,l,e}
{a,s,
o,r,
a,o,r,s,
i,t,
g,n,
g,i,n,t,
a,g,i,n,o,r,s,t,
e,x,
a,m,
a,e,m,x,
l,p,
e,l,p}
a,e,e,l,m,p,x}
a = {a,a,e,e,g,i,l,m,n,o,p,r,s,t,x}
Heap Sort
Este mtodo garantiza que el tiempo de ejecucin siempre es de: O(n log n)

31

El significado de heap en ciencia computacional es el de una cola de prioridades


(priority queue). Tiene las siguientes caractersticas:
Un heap es un arreglo de n posiciones ocupado por los elementos de la cola.
(Nota: se utiliza un arreglo que inicia en la posicin 1 y no en cero, de tal manera
que al implementarla en C se tienen n+1 posiciones en el arreglo.)
Se mapea un rbol binario de tal manera en el arreglo que el nodo en la posicin i
es el padre de los nodos en las posiciones (2*i) y (2*i+1).
El valor en un nodo es mayor o igual a los valores de sus hijos. Por consiguiente,
el nodo padre tiene el mayor valor de todo su subrbol.
Heap Sort consiste en convertir el arreglo en un heap
construir un arreglo ordenado de atrs hacia adelante (mayor a menor) repitiendo
los siguientes pasos:
sacar el valor mximo en el heap (el de la posicin 1)
poner ese valor en el arreglo ordenado
reconstruir el heap con un elemento menos
utilizar el mismo arreglo para el heap y el arreglo ordenado.
Procedimiento Heapsort
/* Recibe como parmetros un arreglo a ordenar y un entero que indica el numero
de datros a ordenar */
void heapsort(int a[], int N) {
int k;
for(k=N/2; k>=1; k--)
downheap(a,N,k);
while(N > 1) {
swap(a,1,N);
downheap(a,--N,1);
}
}
/* el procedimiento downheap ordena el &aacure;rbol de heap para que el nodo
padre sea mayor que sus hijos */
void downheap(int a[], int N, int r) {
int j, v;
v = a[r];
while (r <= N/2) {
j = 2*r;
if(j < N && a[j] < a[j+1]);
j++;
if( v >= a[j])
break;
a[r] = a[j];
r = j;
}

32

a[r] = v;
}
Partition-Exchange Sort o Quicksort
Es un mtodo de ordenamiento recursivo y en lenguajes en dnde no se permite
la recursividad esto puede causar un retraso significativo en la ejecucin del
quicksort, su tiempo de ejecucin es de n log2n en promedio.
void quicksort(int a[], int l, int r) {
int i,j,v;
if(r > l) {
v = a[r];
i = l-1;
j = r;
for(;;) {
while(a[++i] < v && i < r);
while(a[--j] > v && j > l);
if( i >= j)
break;
swap(a,i,j);

a = {a,s,o,r,t,i,n}
aiortsn
ainrtso
ainotsr
ainorst

}
swap(a,i,r);
quicksort(a,l,i-1);
quicksort(a,i+1,r);
}
}

Ordenamiento de raz (radix sort).


Este ordenamiento se basa en los valores de los dgitos reales en las
representaciones de posiciones de los nmeros que se ordenan.
Por ejemplo el nmero 235 se escribe 2 en la posicin de centenas, un 3 en la
posicin de decenas y un 5 en la posicin de unidades.
Reglas para ordenar.
Empezar en el dgito ms significativo y avanzar por los dgitos menos
significativos mientras coinciden los dgitos correspondientes en los dos nmeros.
El nmero con el dgito ms grande en la primera posicin en la cual los dgitos de
los dos nmeros no coinciden es el mayor de los dos (por supuesto s coinciden
todos los dgitos de ambos nmeros, son iguales).
Este mismo principio se toma para Radix Sort, para visualizar esto mejor tenemos
el siguiente ejemplo. En el ejemplo anterior se ordeno de izquierda a derecha.
Ahora vamos a ordenar de derecha a izquierda.
Archivo original: 25 57 48 37 12 92 86 33

33

Asignamos colas basadas en el dgito menos significativo.


Parte delantera Parte posterior
ASORTINGEXAMPLE
0
AEOLMINGEAXTPRS
1
AEAEGINMLO
2
AAEEG
AA
4
AA
EEG
EE
INMLO
LMNO
9
LM
10
NO
Despus de la primera pasada:
STPRX
12 92 33 25 86 57 37 48
SRPT
Colas basadas en el dgito ms significativo.
PRS
RS
Parte delantera Parte posterior
0
1

10
Archivo ordenado: 12 25 33 37 48 57 86 92
#include
#include
#define NUMELTS 20
void radixsort(int x[], int n) {
int front[10], rear[10];
struct {
int info;
int next;
} node[NUMELTS];
int exp, first, i, j, k, p, q, y;

34

/* Inicializar una lista viculada */


for (i = 0; i < n-1; i++) {
node[i].info = x[i];
node[i].next = i+1;
} /* fin del for */
node[n-1].info = x[n-1];
node[n-1].next = -1;
first = 0; /*first es la cabeza de la lista vinculada */
for (k = 1; k < 5; k++) {
/* Suponer que tenemos nmeros de cuatro dgitos */
for (i = 0; i < 10; i++) {
/*Inicializar colas */
rear[i] = -1;
front[i] = -1;
} /*fin del for */
/* Procesar cada elemento en la lista */
while (first != -1) {
p = first;
first = node[first].next;
y = node[p].info;
/* Extraer el ksimo dgito */
exp = pow(10, k-1);
/* elevar 10 a la (k-1)sima potencia */
j = (y/exp) % 10;
/* Insertar y en queue[j] */
q = rear[j];
if (q == -1)
front[j] = p;
else
node[q].next = p;
rear[j] = p;
} /*fin del while */
/* En este punto, cada registro est en su cola bas ndose en el dgito k
Ahora formar una lista nica de todos los elementos de la cola. Encontrar
el primer elemento. */
for (j = 0; j < 10 && front[j] == -1; j++);
;
first = front[j];
/* Vincular las colas restantes */
while (j <= 9) { /*Verificar si se ha terminado */
/*Encontrar el elemento siguiente */
for (i = j+1; i < 10 && front[i] == -1; i++);
;
if (i <= 9) {

35

p = i;
node[rear[j]].next = front[i];
} /* fin del if */
j = i;
} /* fin del while */
node[rear[p]].next = -1;
} /* fin del for */
/* Copiar de regreso al archivo original */
for (i = 0; i < n; i++) {
x[i] = node[first].info;
first = node[first].next;
} /*fin del for */
} /* fin de radixsort*/
int main(void) {
int x[50] = {NULL}, i;
static int n;
printf("\nCadena de nmeros enteros: \n");
for (n = 0;; n++)
if (!scanf("%d", &x[n])) break;
if (n)
radixsort (x, n);
for (i = 0; i < n; i++)
printf("%d ", x[i]);
return 0;
}
Estado de la lista
i

Node[i].info Node[i].next
Inicializacin K = 1 K = 2 K = 3

65

789

-1

-1

-1

123

457

-1

rear = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
2031
front = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
2031

36

k=1
p=0p=1p=2p=3
first = 1 first = 2 first = 3 first = -1
y = 65 y = 789 y = 123 y = 457
exp = 1 exp = 1 exp = 1 exp = 1
j=5j=9j=3j=7
q = -1 q = -1 q = -1 q = -1
si q == -1 si q == -1 si q == -1 si q == -1
front[5] = 0 front[9] = 1 front[3] = 2 front[7] = 3
rear[5] = 0 rear[9] = 1 rear[3] = 2 rear[7] = 3
j=3
first = 2
while ( j <= 9)
i=5
si i <= 9
p=5
node[2].next = 0
j=5
i=7
si i <= 9
p=7
node[0].next = 3
j=5
i=9
si i <= 9
p=9
node[2].next = 1
j=9
fin del while
p=9
node[1].next = -1
Caractersticas.
Debido a que el ciclo for (k = 1; k <= m; k++) externo se recorre m veces (una para
cada dgito) y el ciclo interior n veces (una para cada elemento en el archivo) el
ordenamiento es de aproximadamente (m*n).
Si las llaves son complejas (es decir, si casi cada nmero que puede ser una llave
lo es en realidad) m se aproxima a log n, por lo que (m*n) se aproxima a (n log n).
Si la cantidad de dgitos es grande, en ocasiones es ms eficiente ordenar el
archivo aplicando primero el ordenamiento de raz a los dgitos ms significativos y
despus utilizando insercin directa sobre el archivo ordenado.
Ventajas.
El ordenamiento es razonablemente eficiente si el nmero de dgitos en las llaves
no es demasiado grande.

37

Si las mquinas tienen la ventaja de ordenar los dgitos (sobre todo si estn en
binario) lo ejecutaran con mucho mayor rapidez de lo que ejecutan una
comparacin de dos llaves completas.
Ordenamiento por clculo de direccin.
Se aplica una funcin f a cada llave. El resultado de esta funcin determina dentro
de cul entre varios archivos se va a colocar el registro. La funcin debe tener la
propiedad de que si x<=y,f(x),<=f(y). Esta funcin se denomina preservadora de
orden. Por tanto, todos lo registros en un subarchivo tendrn llaves que sean
menores o iguales que las llaves de los registros en otros subarchivos. Un
elemento se coloca en un subarchivo en secuencia correcta utilizando cualquier
mtodo de ordenamiento; con frecuencia se utiliza la insercin simple. Despus de
que se han colocado todos los elementos del archivo original en subarchivos se
concatenan para producir el resultado ordenado.
Por ejemplo, considerar el archivo de muestra.
25 57 48 37 12 92 86 33
Vamos a crear 10 subarchivos, uno para cada uno de los 10 primeros dgitos
posibles. Al principio , cada uno de estos subarchivos est vaco. Se declara un
arreglo de apuntadores f[10], en donde f[i] apunta al primer elemento en el archivo
cuyo dgito es i. Despus de examinar el primer elemento (25), se coloca en el
archivo encabezado por f[2]. Cada uno de los subarchivos se conserva como una
lista ligada ordenada de los elementos de arreglo originales. Despus de procesar
cada uno de los elementos en el archivo original, aparecen los subarchivos como
se muestra a continuacin.
Algoritmo de ordenamiento.
Presentamos una rutina para implementar el ordenamiento de clculo de
direccin. La rutina supone un arreglo de nmeros de 2 dgitos y utiliza el primer
dgito de cada nmero para asignar cada nmero a un subarchivo.
#define N...
/* N es el numero de elementos a ordenar*/
addr( int x[],int n) {
int f[10],first,i,j,p,y;
struct{
int info;
int next;
} node[N]
/* Inicializar la lista ligada disponible */
for(i=0;i<n-1;i++)
node[i].next=i+1;
node[n-1].next=-1;
for(i=0;i<n;i++)
node[i].info=x[i];
/* Inicializar los apuntadores */
for(i=0;i<10;i++)

38

f[i]=-1;
for(i=0;i<n;i++)
{ /* Insertar sucesivamente c/elemento en su subarchivo
/* respectivo utilizando insercin de lista */
y=x[i];
first=y/10; /* Encontrar el dgito de las decenas */
/* Buscar en la lista ligada */
place(&f[first],y);
/* place inserta "y" en su posicin correcta en la lista */
/* a la que se apunta mediante f[first] */
}
/* Copiar los nmeros de regreso al erreglo x */
i=0;
for(j=0;j<10;j++) {
p=f[j];
while(p!=-1) {
x[i++]=node[p].info;
p=node[p].next;
}
}
}
Programa de ordenamiento por clculo de direccin.
#include <stdio.h>
#include <conio.h>
#define N 8
main(void) {
int x[N],f[10];
int i,j,p,a,s,y,first;
struct {
int info;
int next;
}node[N];
clrscr();
for(i=0;i<N;i++) {
/*lectura del arreglo x[N] a ordenar*/
printf("x[%d]=",i);
scanf("%d",&x[i]);
}
for(i=0;i<N-1;i++)
/*Inicio de la lista disponible*/
node[i].next=i+;
/*apuntadores*/
node[N-1].next=-1;
for(i=0;i<N;i++)
/*dato*/
node[i].info=x[i];
for(i=0;i<10;i++)
/*Inicializacin de apuntadores f[10]*/
f[i]=-1;
/*al principio f[i] no apunta a nada */

39

for(i=0;i<N;i++) {
/*Creacin de sub-listas*/
y=x[i];
/*clculo del digito de las decenas*/
first=y/10;
if(f[first]==-1) {
/*f[first] no apunta a nign dato*/
f[first]=i;
node[i].next=-1;
}
else {
/* f[first] apunta a un dato*/
if(node[f[first]].next==-1) { /*apunta al primer dato en lista*/
if(node[f[first]].info < y) {
node[f[first]].next=i;
node[i].next=-1;
}
else {
node[i].next=f[first];
node[f[first]].next=-1;
f[first]=i;
}
}
else {
/*Se continua la lista*/
a=f[first];
/*a= anterior*/
s=node[a].next;
/*s= siguiente*/
if(y<node[f[first]].info) {
f[first]=i;
node[i].next=a;
}
else {
while(y>node[s].info&&s!=-1) {
a=s;
s=node[s].next;
}
node[a].next=i; /*i semejante a temp*/
node[i].next=s;
}
}
}
}
i=0;
/*Copiar los nmeros de regreso*/
for(j=0;j<10;j++) {
/* al arreglo x[N] */
p=f[j];
while(p!=-1) {
x[i++]=node[p].info;
p=node[p].next;
}
}

40

printf("\n");
for(i=0;i<N;i++)
printf("x[%d]=%d\n",i,x[i]);
getchar();
}
Los requisitos de espacio del ordenamiento de calculo de direccin son
aproximadamente 2*n (utilizado mediante el arreglo node) ms algunos nodos de
encabezado y variables temporales. Observe que si los datos originales se
proporcionan en la forma de una lista ligada y no como un arreglo secuencia l, no
es necesario conservar el arreglo x y la estructura vinculada node.
Para evaluar los requisitos de tiempo para el ordenamiento considere lo siguiente:
si la distribucin aproximada de los n elementos originales est uniformemente
distribuida por los m subarchivos y el valor de n/m es aproximadamente 1, el
tiempo de ordenamiento es casi O(n),dado que la funcin asigna cada elemento a
su propio archivo y se requiere poco trabajo adicional para colocar el elemento
dentro del subarchivo mismo. Por otra parte, si n/m es mucho ms grande que 1, o
si el archivo original no esta uniformemente distribuido por los m subarchivos, se
requiere bastante trabajo para insertar un elemento en su propio subarchivo.

VI.5. Procedimiento
1. En la seccin de ejercicios se describen una serie de problemas en los
que es necesario aplicar los algoritmos de ordenamiento o busqueda
para hacer el programa de solucin al problema descrito.
2. Elaborar el anlisis del problema y describir las estructuras de datos
necesarias y el modelado de la solucin en papel.
3. Codificar el programa en lenguaje C.
VI.6. Ejercicios
1. Se dispone de una lista de nmeros enteros clasificados en orden creciente. Se
desea saber si un nmero dado introducido desde el teclado se encuentra en la
lista. En caso afirmativo, averiguar su posicin, y en caso negativo se desea
conocer su posicin en la lista e insertarlo en su posicin.
2. Supongamos que se tiene un vector de N elementos que deben ser ordenados,
utilizando el mtodo de burbuja, cuantas comparaciones y cuantos intercambios
se requieren para clasificar la secuencia si:
o Los elementos ya estn ordenados.
o Los elementos estn en orden inverso.
Escribir un programa que muestre estos datos (comparaciones e intercambios
para N elementos).

41

3. Se tienen tres vectores de Z elementos:


-- El vector A con los nombres
-- El vector B con los promedios
-- El vector C con el nmero de materias aprobadas.
Escriba un programa que lea un nombre, lo busque y si lo encuentra informe su
promedio y nmero de materias aprobadas. Si el nombre dado no est en el
arreglo, envi un mensaje adecuado. Considerar dos casos:
o Considere que los arreglos estn ordenados.
o Considere que los arreglos estn desordenados.
4. Realizar un programa que compare el tiempo de calculo de las bsquedas
secuencial y binaria. Una lista A se rellena con 2.000 enteros aleatorios en el
rango 0 .. 1999 y a continuacin se ordena. Una segunda lista B se rellena con
500 enteros aleatorios en el mismo rango. Los elementos de B se utilizan como
clave de los algoritmos de bsqueda.
5. Hacer un programa que cree un array de 100 enteros aleatorios en el rango de
1 a 200 y a continuacin utilizando una bsqueda secuencial, realizar la
bsqueda de 50 enteros seleccionados aleatoriamente (iguales o distintos). Al
final del programa se deben visualizar las siguientes estadsticas:
-- Numero de bsqueda con xito
--Numero de bsquedas fallidas

42

FUENTES CONSULTADAS
[Joyanes1998] Joyanes Aguilar, Luis y Zahoneri Martnez, Ignacio, (1998)
Estructura de datos. Algoritmos, abstraccin y objetos. Ed.
McGrawHill, Espaa.
[Joyanes2003] Joyanes Aguilar, Luis (2003) Fundamentos de la programacin
algoritmos y estructuras de datos. Tercera edicin, Ed.
McGrawHill. Espaa.
[Oviedo2003] Oviedo Regino, Efrain (2003) Lgica de programacin. Ed.
Ecoediciones. Espaa.
[Tenembaum1996] Tenembaum, Aaron M. Tenembaum, Aarn M., Langsam,
Yedidhah y Augenstein, Moshe A., (1996) Estructuras de datos con
C y C++. Segunda Edicin Prentice hall, Mxico.
[Goodrich2002] Goodrich, Michael T., Tamassia, Robert, (2002). Estructura de
datos y algoritmos en Java. Segunda Edicin ed. CECSA, Mxico.

43