Escolar Documentos
Profissional Documentos
Cultura Documentos
Prctica
Pag.
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
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
Se refieren a un
grupo de casillas de
memoria
Estticos
Dinmicos
Arreglos, Registros,
Archivos, Cadenas
Listas, Arboles,
Grafos
Inf. Sig.
Inf. Sig.
Inf. Sig.
Inf. Sig.
Null
Nodo
Nodo
Nodo
Nodo
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:
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
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
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
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.
10
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
13
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
3. Implementar una estructura de datos que sirva como contador de cada palabra
diferente que aparece en un texto.
16
17
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).
20
IV.3. Materiales
Hojas de papel bond o cuaderno, lpiz o boligrafo.
IV.4. Descripcin
Pilas y colas
Sale
Entra
Tope
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()
21
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;
}
}
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
Ejemplo
24
No es necesario mover
todos los elementos
25
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.
cola
e f
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.
27
Selection Sort
28
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
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
31
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);
}
}
33
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
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
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