Algoritmos y Estructuras de Datos 3. Estructuras de Datos Bsicas 3.3.

Listas Introduccin Una lista enlazada o encadenada es una coleccin de elementos nodos, en donde cada uno contiene datos y un enlace o liga. Un nodo es una secuencia de caracteres en memoria dividida en campos (de cualquier tipo). Un nodo siempre contiene la direccin de memoria del siguiente nodo de informacin si este existe. Un apuntador es la direccin de memoria de un nodo La figura siguiente muestra la estructura de un nodo:
DATO LINK

El campo liga, que es de tipo puntero, es el que se usa para establecer la liga con el siguiente nodo de la lista. Si el nodo fuera el ltimo, este campo recibe como valor NIL (vaco). A continuacin se muestra el esquema de una lista : Juan Luis Mara Sofa
NULL

Forma de declarar una lista enlazada struct nodo { char dato[10]; struct nodo *link; }; struct nodo *lista; /* lista es un puntero a nodo*/ Ej. Referenciar un miembro de nodo: lista->dato =hola; lista->link = NULL; */ lista est apuntando a vaco*/ Inicializacin y Borrado de variables de tipo Puntero Cuando se quiere usar una variable tipo puntero no basta slo con declararla, es necesario asignarle un espacio en memoria. La funcion new, asigna almacenamiento para una variable de un tipo determinado y guarda la direccin de la celda de memoria en la variable. Ej. Asignacin de memoria para un nodo: lista = new nodo; Por otro lado, cuando la variable se deja de usar, se debe liberar la posicin de memoria ocupada por la variable, para ello se utiliza el procedimiento delete. Ej. Libera la posicin de memoria ocupada por un nodo: delete lista;

Operaciones en Listas Encadenadas Las operaciones que podemos realizar sobre listas encadenadas son las siguientes: Recorrido. Esta operacin consiste en visitar cada uno de los nodos que forman la lista. Para recorrer todos los nodos de la lista, se comienza con el primero, se toma el valor del campo liga para avanzar al segundo nodo, el campo liga de este nodo nos dar la direccin del tercer nodo, y as sucesivamente. Insercin. Esta operacin consiste en agregar un nuevo nodo a la lista. Para esta operacin se pueden considerar tres casos: o Insertar un nodo al inicio. o Insertar un nodo antes o despus de cierto nodo. o Insertar un nodo al final. Borrado. La operacin de borrado consiste en quitar un nodo de la lista, redefiniendo las ligas que correspondan. Se pueden presentar cuatro casos: o Eliminar el primer nodo. o Eliminar el ltimo nodo. o Eliminar un nodo con cierta informacin. o Eliminar el nodo anterior o posterior al nodo cierta con informacin. Bsqueda. Esta operacin consiste en visitar cada uno de los nodos, tomando al campo liga como puntero al siguiente nodo a visitar. Algoritmos sobre listas lineales Las listas lineales encadenadas siempre deben mantener un puntero al inicio el cual se llama raiz o tope. Se usar la variable TOP para referenciar al primer nodo de la lista y TOP->dato y TOP->link para hacer referencia al dato almacenado y al link al siguiente nodo respectivamente. struct nodo { char dato; struct nodo *link; }; Algoritmo de Creacin
struct nodo *Crea_lista_final()/*donde p es de tipo puntero a nodo}*/ { struct nodo *p, *top, *q; /*top es un puntero al inicio de la lista de nodos*/ int respuesta; /*q es de tipo puntero a nodo*/ TOP = NULL; respuesta = 1; while (respuesta) { p = new nodo; cout << Dato; cin >> p->dato; if (top == NULL) { top = p; q = p;} else { q->link = p; p->link = NULL; q = p; } cout << Otro nodo? (si=1; no=0); cin >> respuesta;

} return(top); } struct nodo *Crea_lista_inicio()/*donde p es de tipo puntero a nodo}*/ { struct nodo *top; /*top es un puntero al inicio de la lista de nodos*/ int respuesta; top = NULL; respuesta = 1; while (respuesta) { p = new nodo; cout << Dato; cin >> p->dato; if (top == NULL) top = p; else { p->link = top; top = p;} cout << Otro nodo? (si=1; no=0); cin >> respuesta; } return(top); }

Algoritmo para Recorrido

Recorre_lista(struct nodo *top) /*top es un puntero al inicio de una lista*/ { struct nodo *p; p = top; while (p <> NULL) { cout << p->dato; p = p->link;} }

Algoritmo para insertar un nodo a una lista que ya existe y que est apuntada por top
inserta_final_lista(struct nodo *top) { struct nodo *p, *q; p = top; while (p->link <> NULL) p = p->link; q = new nodo; cout << Dato; cin >> q->dato; p->link = q; q->link = NULL; } inserta_inicio_lista(top) { struct nodo *p; p = new nodo; cout << Dato; cin >> p->dato; p->link = top; top = p; }

Algoritmo para insertar un nodo antes/despus de 'X' informacin

Inserta_antes_despues(struct nodo *top, char x) { struct nodo *p, *q; int respuesta; p = top; cout << antes(1)/despus(0)) cin >> respuesta; if (respuesta) { while (p <> NULL) { if (p->dato == x) { q = new nodo; cout << Dato; cin >> q->dato; q->link = p; if (p == top) top = q; else r->link = q; }else { r = p; p = p->link;} } }else { while (p <> NULL) { if (p->dato == x) { q = new nodo; cout << Dato; cin >> q->dato; if (p == top || p->link==NULL) { p->link = q; q->link = NULL;} else { q->link = p->link; p->link = q;} }else p = p->link; } } }

Algoritmo para borrar un nodo que tiene el dato X

elimina_nodo (struct nodo *top, char x) { struct nodo *p, *q; p = top; while (p <> NULL) { if(p->dato == x) if (p == top) if (p->link == NULL) top = NULL; else top = top->link; else q->link = p->link; delete p; else { q = p; p = p->link;} } }

Listas Circulares Las listas circulares tienen la caracterstica de que el ltimo elemento de la lista apunta al primero. La siguiente figura es una representacin grfica de una lista circular. Juan Luis Mara Sofa

Algunos algoritmos sobre listas circulares son: Algoritmo de creacin

struct nodo *Crea_lista_circular_final()/*donde p es de tipo puntero a nodo}*/ { struct nodo *p, *top, *q; /*top es un puntero al inicio de la lista de nodos*/ int respuesta; /*q es de tipo puntero a nodo*/ top = NULL; respuesta = 1; while (respuesta) { p = new nodo; cout << Dato; cin >> p->dato; if (top == NULL) { top = p; q = p;} else { q->link = p; q = p; } p->link = top; cout << Otro nodo? (si=1; no=0); cin >> respuesta; } return(top); }

Algoritmo para recorrer la lista

Recorre_circular(struct nodo *top) { struct nodo *p; p = top; if (p <> NULL) { cout << p->dato; p = p->link;} while (p <> top && p <> NULL) { cout << p->dato; p = p->link;} }

Algoritmo para borrar un nodo que contiene la informacin X

Elimina_circular(struct nodo *top, char x) { struct nodo *p, *q, *r; q = top; r = top; p = top; while (q->link <> top) /*posiciona el puntero q al final de la lista*/ q = q->link; do { if (p->dato == x)

if (p == top) if (top->link=top) top = NULL; else { top = top->link; q->link = top;} else r->link = p->link; delete p; p = top; } else { r = p; p = p->link;}

} while (p <> top); }

Listas doblemente encadenadas Una lista doble, o doblemente ligada es una coleccin de nodos en la cual cada nodo tiene dos punteros, uno de ellos apuntando a su predecesor (Ant) y otro a su sucesor (Sig). Por medio de estos punteros se podr avanzar o retroceder a travs de la lista, segn se tomen las direcciones de uno u otro puntero. En estas listas cada nodo conoce quien es el siguiente nodo y quien es el anterior.
NODO

Ant Dato Sig

Donde Ant y Sig son punteros a NODO.

TOP NULL

NULL

FIN

Dado que las listas doblemente encadenadas se pueden recorrer de izquierda a derecha y vise versa Es necesario mantener dos punteros indicando los extremos de la lista, el puntero TOP al inicio y el puntero FIN al trmino. Existen dos tipos de listas doblemente ligadas: Listas dobles lineales. En este tipo de lista doble, tanto el puntero izquierdo del primer nodo como el derecho del ltimo nodo apuntan a NULL. Listas dobles circulares. En este tipo de lista doble, el puntero izquierdo del primer nodo apunta al ltimo nodo de la lista, y el puntero derecho del ltimo nodo apunta al primer nodo de la lista.

Procedimiento de crear el primer nodo de una lista doblemente enlazada

p1 1. 2. 3. 4. 5. 6. p =new nodo p->dato= INFO p->sig = NULL p->ant = NULL TOP = p FIN = p TOP5 NULL3

INFO2

NIL4

FIN6

Procedimiento para insertar un nodo al comienzo

1. 2. 3. 4. 5. 6. p = new nodo p->dato= INFO p->sig = TOP p->ant = NULL TOP->ant = p TOP = p

Procedimiento para insertar despus de un nodo de referencia Se recorre la lista hasta encontrar el nodo de referencia, que queda apuntado por q
1. 2. 3. 4. 5. 6. p = new nodo; p->dato = INFO p->sig = q->sig p->ant = q q->sig->ant = p q->sig = p

Procedimiento para insertar antes de un nodo de referencia Se recorre la lista hasta encontrar el nodo de referencia, que queda apuntado por q
1. 2. 3. 4. 5. 6. p = new nodo p->dato = INFO p->sig = q p->ant = q->ant q->ant->sig = p q->ant = p

Algoritmo de creacin de lista dobles circulares

top = NULL repite p= new nodo lee(p->dato) si top=NULL entonces p->sig = p p->ant = p top = p en caso contrario p->sig = top p->ant = top->ant top->ant = p p->ant->sig = p top = p mensaje(otro nodo?) lee (respuesta) hasta respuesta=no

Algoritmo para recorrer la lista Recorrido a la Derecha Recorrido a la Izquierda

P = top repite escribe(p->dato) p = p->sig hasta p = top->ant

P = top repite escribe(p->dato) p = p->ant hasta p = top->sig

Algoritmo para insertar

Antes de x p = top lee(x) repite si p->dato = x entonces q = new nodo leer(q->dato) si p = top entonces top = q q->sig = p q->ant = p->ant p->sig->ant = q p->ant = q p = top en caso contrario p = p->sig hasta p = top Despus de x p = top lee(x) repite si p->dato = x entonces q = new nodo leer(q->dato) q->sig = p->sig q->ant = p p->sig->ant = q p->sig = q p = top en caso contrario p = p->sig hasta p=top

Algoritmo para borrar un nodo

p = top lee(valor_a_borrar) repite si p->dato = valor_a_borrar entonces p->sig->ant = p->ant p->ant->sig = p->sig si p = top entonces si p->sig = p->ant entonces top = NULL en caso contrario top = top->sig dispose(p) p = top en caso contrario p = p->sig hasta p = top

Algoritmos y Estructuras de Datos Gua de Ejercicios LISTAS

1. Construya un algoritmo para crear una lista lineal que contenga valores numricos entregados por pantalla. 2. Suponga que ya tiene creada la lista anterior, cree un algoritmo que entregue como resultado la suma total de los nmeros de los nodos y la cantidad de nodos en la lista. 3. Considere la lista que cre en el ejercicio 1, cree un algoritmo que entregue la suma total de los nmeros mayores que 10 y la cantidad de nmeros menores o iguales a 10 que contiene la lista. 4. Considere que tiene una lista lineal que contiene como dato el nombre del mes y la cantidad total de das que posee:

Enero 31

Febrero 28

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

Diciembre 31

nulo

Cree un algoritmo que recorra la lista anterior y cree una segunda lista slo con aquellos meses que tengan 31 das. 5. Suponga que tiene una lista que contiene los alumnos que inscribieron la asignatura Informtica II en la primera inscripcin de asignaturas. Luego del proceso de reinscripcin se gener una segunda lista con los nuevos alumnos que se incorporaron al curso. Ambas listas contienen la misma informacin: el nombre del alumno y su rut. Cree un algoritmo que agregue al final de la lista inicial los alumnos que se incorporaron al curso. 6. Suponga que tiene un listado de alumnos de un curso dividido en dos listas lineales. Una lista contiene todos los nombres de los hombres del curso ordenados en forma ascendente y, la otra lista contiene los nombres de las mujeres ordenado en forma ascendente. Escriba un algoritmo que genere una lista resultante con los nombres de todas las personas del curso (hombres y mujeres) ordenado en forma ascendente. 7. Un Chef tiene todas los tipos de comidas y los ingredientes que estas contienen, almacenadas en una estructura utilizando listas encadenadas de la siguiente forma: Comida
Pavo Nogado Asado Alemn

Lomo Mignon

Championes 7

Carne

Tocino 1

Pavo 3

Nueces 1

Carne 9

Ingredientes Suponga: La lista de comidas contiene el nombre de la comida, un link a la lista de sus ingredientes y un link a la siguiente comida. La lista de ingredientes contiene el nombre del ingrediente, la cantidad necesaria y un link al siguiente ingrediente. Una comida puede tiene al menos un ingrediente.

Se pide: a. Defina formalmente las estructuras de datos necesarias para representar estas listas. (5 ptos). b. Al chef no le queda stock de carne. Escriba un algoritmo que calcule la cantidad de carne que necesita comprar el chef para poder preparar todas sus comidas.(20 ptos) c. Calcule el orden del algoritmo. (5 ptos).

8. En una empresa se tiene la informacin almacenada en listas enlazadas. La informacin del trabajador est en una lista con la siguiente estructura: struct nodo { char nombre[30]; char cargo[20]; int nro_cargas; struct nodo *link; } Adems, existe una segunda lista que contiene para cada cargo el sueldo base correspondiente, con la siguiente estructura: struct nodo1 { char cargo[20]; int sueldo_base; struct nodo *link; } a. Cree una tercera lista (nombre del trabajador, sueldo) con el sueldo de cada trabajador, si se sabe que: sueldo = sueldo_base + nro_cargas*5000 b. Defina todas las estructuras de datos que ocupar. Supuestos: La lista de trabajadores no est vaca. Todos los cargos aparecen en la lista de sueldo base por cargo (y no repetido). 9. En un colegio se tienen dos cursos de pre-kinder (A y B) cuyos alumnos se encuentran almacenados en dos listas lineales que contienen el nombre del alumno y su edad en meses. Existe diferencia entre los cursos producto de que hay nios de edades muy diferentes que estn juntos, por lo tanto, se ha decidido reestructurar los cursos de manera tal que en uno de ellos estn los alumnos de hasta 53 meses ( 41/2 aos) y en el otro los alumnos que tengan ms de 53 meses. Se pide: a) Escribir un algoritmo que genere dos listados (listas encadenadas) de los alumnos separados por edad. (Nota: considere que inicialmente tiene dos listas y debe entregar como resultado otras dos listas diferentes). (18 ptos.) b) Calcular el orden de ejecucin del algoritmo. (5 ptos.) 10. Se tiene una lista lineal doblemente encadenada que contiene nmeros enteros positivos (>0): a) Construya un algoritmo que elimine de la lista aquellos nodos que contengan nmeros pares. (15 ptos.) La lista puede estar vaca y puede tener o no nmeros pares. b) Diga cual es el orden de ejecucin del algoritmo y por qu. (6 ptos.) 11. Suponga que tiene un listado de n alumnos y su nota final almacenada en una estructura tipo lista simplemente encadenada: c) Construya un algoritmo que calcule el promedio del curso y entregue la cantidad de alumnos con nota menor a 4,0 y la cantidad de alumnos con nota mayor o igual a 4,0. (12 ptos.) d) Especifique claramente la estructura del nodo de la lista. (3 ptos). e) Calcule el orden de ejecucin del algoritmo (5 ptos.)

Algoritmos y Estructuras de Datos 3. Estructuras de datos en Memoria Principal 3.1.Tipo de Dato Abstracto Pila (Stack) Las pilas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la posicin en la cual pueden realizarse las inserciones y las extracciones de elementos. Una pila es una lista de elementos en la que se pueden insertar y eliminar elementos slo por uno de los extremos. Como consecuencia, los elementos de una pila sern eliminados en orden inverso al que se insertaron. Es decir, el ltimo elemento que se meti a la pila ser el primero en salir de ella. En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una alacena, una pila de latas en un supermercado, una pila de papeles sobre un escritorio, golosinas en una mquina de ventas automticas, etc. Debido al orden en que se insertan y eliminan los elementos en una pila, tambin se le conoce como estructura LIFO (Last In, First Out: ltimo en entrar, primero en salir). Representacin en Memoria Las pilas no son estructuras de datos fundamentales, es decir, no estn definidas como tales en los lenguajes de programacin. Las pilas pueden representarse mediante el uso de: Arreglos. Listas enlazadas.

Pilas representadas mediante Arreglos

Se debe definir el tamao mximo de la pila, adems de un apuntador (tope: entero) que indica la cima o el tope de la pila, es decir, dnde se debe insertar el prximo elemento. La representacin grfica de una pila es la siguiente: Arreglo : tamao mximo n=5

tope=1 DATO1 Al utilizar arreglos para implementar pilas, tenemos la limitante de espacio de memoria reservada. Una vez establecido un mximo de capacidad para la pila, ya no es posible insertar ms elementos. Inicialmente el tope debe estar en un extremo del arreglo. De acuerdo a esto existen dos formas de implementar el arreglo: creciente hacia abajo o creciente hacia arriba:

0 1 . . n-3 n-2 n-1

///////////// /////////////

push

pop

0 1 . . n-3 n-2 n-1

Creciente hacia abajo Pila vacia: tope = 0 Pila llena : tope = n Operaciones en Pilas
Tipo Operacin Constructora Modificadora Modificadora Analizadora Analizadora Operacin InicPila AdicPila ElimPila InfoPila VaciaPila Dominio Codominio Pila Pila Pila TipoP int Especificacin

//////////////// push //////////////// Creciente hacia arriba Pila vaca: tope = n-1 Pila llena : tope = -1

pop

Descripcin Crea una pila vaca Inserta un elemento en el tope de la pila Suprime el elemento que est en el tope de la pila Devuelve el elemento que est en el tope de la pila Devuelve verdadero (1) si la Pila est vaca y falso (0) en caso contrario Regresa verdadero (1) si la Pila est llena y falso (0) si no lo est

Pila, TipoP Pila Pila Pila

Pila *InicPila(void) void AdicPila (Pila *p, TipoP dato) void ElimPila (Pila *p) TipoP InfoPila (Pila *p) int VaciaPila(Pila *p)

Analizadora

LlenaPila

Pila

int

int LlenaPila(Pila *p)

Destructora

DestruirPila

Pila

void DestruirPila(Pila *p)

Implementacin de Pilas basadas en Arreglos Para representar una Pila con arreglos es posible estructurarla como un registro de dos campos: un arreglo para contener los datos de la pila y un campo para almacenar la posicin del elemento superior de la pila (llamado tope). Suponga que se quiere implementar una pila de tamao 30, para almacenar caracteres, entonces: #include <stdio.h> #include <alloc.h> #include <conio.h> #define TAM 30 #define TRUE 1 #define FALSE 0 typedef char TipoP; typedef struct { TipoP info[TAM]; int tope; }TPila;

TPila *InicPila( ) { TPila *p = (TPila *) malloc (sizeof(TPila)); p->tope = 0; /*Se tiene una pila vaca*/ return(p); } int VaciaPila(TPila *p) { if (p->tope == 0) return(TRUE); else return(FALSE); } int LlenaPila(TPila *p) { if (p->tope == TAM) return TRUE; else return FALSE; } void AdicPila(TPila *p, TipoP dato) { if (LlenaPila(p)) printf("Error, Pila Llena\n"); else { p->info[p->tope] = dato; p->tope++; } } void ElimPila(TPila *p) { if (VaciaPila(p)) printf ("Error, Pila Vaca\n"); else p->tope--; /*Elimina el elemento del tope*/ } TipoP InfoPila(TPila *p) { if (VaciaPila(p)) { printf ("Error, Pila Vaca\n"); return(0);} else return(p->info[p->tope-1]); } void DestruirPila(TPila *p) { free(p); } void main() { TipoP valor; TPila *pp; char operacion; int respuesta =1;

pp = InicPila(); while(respuesta) { printf("Ingrese operacion: \n"); printf(" 1: pila vacia\n"); printf(" 2: ingresa un elemento\n"); printf(" 3: devuelve el elemento del tope\n"); printf(" 4: elimina un elemento\n"); printf(" 5: pila llena\n"); printf("Operacion: "); scanf("%c",&operacion); getchar(); switch(operacion) { case '1': printf("Esta vacia?(1:si; 0:no): %i \n", VaciaPila(pp)); break; case '2': printf("ingrese elemento: "); scanf("%c",&valor); getchar(); AdicPila(pp,valor); break; case '3': if(!VaciaPila(pp)) printf("El elemento del tope es %c \n", InfoPila(pp)); break; case '4': ElimPila(pp); break; case '5': printf("Esta llena? (1:si; 0:no): %i \n", LlenaPila(pp)); break; } printf("Desea ingresar otra operacion (0/1): "); scanf("%i",&respuesta); getchar(); } } Ejercicios: 1.- Leer una secuencia arbitraria de caracteres e imprimirla en orden inverso. 2.- Revisa parntesis de una expresin matemtica. Ej. [[2+3]*5+ {(23*12)/(15-{2*4})}] Solucin: - Cada vez que encuentra un parntesis abierto, lo guarda en la pila. - Cuando encuentra un parntesis cerrado saca el elemento del tope de la pila y los compara. Si son del mismo tipo, contina la revisin, si no, existe un error en la expresin. - Cuando termina de recorrer la cadena que contiene la expresin, la pila debe quedar vaca, si no, existe error en la expresin.

Algoritmos y Estructuras de Datos 3. Estructuras de datos en Memoria Principal 3.2. Tipo de Dato Abstracto Fila o Cola FIFO Las colas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la posicin en la cual pueden realizarse las inserciones y las extracciones de elementos. Una cola es una lista de elementos en la que se insertan elementos por un extremo y se eliminan elementos por el extremo opuesto. Como consecuencia, los elementos de una cola sern eliminados en el mismo orden en que se insertaron. Es decir, el primer elemento que se meti a la cola ser el primero en salir de ella. En la vida cotidiana existen muchos ejemplos de colas, una cola para pagar cuentas en el banco, una cola de llamadas telefnicas en una central, una cola de impresin, etc. Debido al orden en que se insertan y eliminan los elementos en una cola, tambin se le conoce como estructura FIFO (First In, First Out: primero en entrar, primero en salir). Representacin en Memoria Las colas no son estructuras de datos fundamentales, es decir, no estn definidas como tales en los lenguajes de programacin. Las colas pueden representarse mediante el uso de : Arreglos. Listas enlazadas.

Representacin de colas mediante Arreglos

Existen tres mtodos diferentes para representar una cola mediante arreglos: Primer Mtodo: Se define un arreglo de tamao mximo y un apuntador al frente de la cola (primer elemento) y uno al final de la cola (prximo espacio libre). Cada vez que se inserta un nuevo elemento se incrementa el apuntador del final hasta que se llega al tamao mximo ms uno. Cada vez que se extrae un elemento el apuntador al frente debe aumentar en uno hasta que frente es igual a final. La representacin grfica de una cola es la siguiente: Arreglo : tamao mximo 4 0 A frente =0 1 B 2 Final = 2 3 El problema con este tipo de representacin es que si se inserta el tamao mximo de elementos del arreglo, no se podr seguir insertando aunque se hayan extrado elementos. Ejemplo: Realice en forma grfica la siguiente secuencia de operaciones: in(A), in(B), in(C), out(A), in(D), out(B), out(C), in(E), in(F). Registre cada vez los valores de frente y final.

La cola est vaca si frente = final y la cola est llena si final = tam_max. En esta representacin tanto la insercin de elementos como la eliminacin son de O(1). Segundo Mtodo: Una forma de solucionar este problema es desplazar los datos hacia arriba cada vez que se extrae un elemento. De esta forma el dato a extraer siempre estar en la primera posicin del arreglo. Ejemplo: Realice en forma grfica la siguiente secuencia de operaciones: in(A), in(B), in(C), out(A), in(D), out(B), out(C), in(E), in(F). Registre cada vez los valores de frente y final. El problema que surge con este mtodo es que la insercin es de O(1) y la extraccin se incrementa a O(n) por tener que hacer los corrimientos. Tercer Mtodo: Este mtodo consiste en implementar la cola utilizando un buffer circular, en este caso tanto la insercin como la extraccin de elementos se mantienen de O(1). El apuntador frente siempre est en la posicin donde se debe extraer el prximo elemento y el apuntador final estar en la posicin donde se debe insertar el prximo elemento, Si final est en la posicin del tamao mximo del arreglo debe ser inicializado en el primer elemento del arreglo de manera de continuar circularmente, esto siempre y cuando frente no sea igual al primer elemento, en cuyo caso la cola estar llena. El apuntador frente debe ser incrementado cada vez que se extrae un elemento e inicializado en la primera posicin del arreglo cuando se extraiga elemento de la ltima posicin del arreglo, esto siempre y cuando frente sea distinto de final en cuyo caso la cola estar vaca. El problema con esta representacin es que la condicin frente = final se aplica tanto para la cola llena como para la cola vaca. Para solucionar esto se utiliza una variable para almacenar el nmero de elementos de la cola. Si la variable es igual a cero la cola est vaca, cuando la variable es igual al tamao mximo del arreglo la cola est llena. Operaciones
Tipo Operacin Constructora Modificadora Modificadora Analizadora Analizadora Operacin InicCola AdicCola ElimCola InfoCola VaciaCola Dominio Codominio Cola Cola Cola TipoC int Especificacin Cola*InicCola(void) void AdicCola (Cola *p, TipoC dato) void ElimCola (Cola *c) TipoC InfoCola (Cola *c) int VaciaCola(Cola *c) Descripcin Crea una cola vaca Inserta un elemento en el final de la cola Suprime el elemento que est en el frente de la cola Devuelve el elemento que est en el frente de la cola Devuelve verdadero (1) si la cola est vaca y falso (0) en caso contrario Regresa verdadero (1) si la cola est llena y falso (0) si no lo est Libera la memoria

Cola, TipoC Cola Cola Cola

Analizadora Destructora

LlenaCola DestruirCola

Cola Cola

int

int LlenaCola(Cola *c) void DestruirCola(Cola *c)

Implementacin de Colas basadas en Arreglos A continuacin se muestra la estructura de datos y funciones para representar una cola de enteros de tamao 20, por el mtodo 1: #include <stdio.h> #include <alloc.h> #include <conio.h> #define TAM 20 #define TRUE 1 #define FALSO 0 typedef int TipoC; typedef struct { TipoC info[TAM]; int frente, final; }TCola; TCola *InicCola() { TCola *c = (TCola *) malloc (sizeof(TCola)); c->final = 0; c->frente = 0; return(c); } int VaciaCola(TCola *c) { if ((c->final == c->frente)) return(TRUE); else return(FALSE); } int LlenaCola(TCola *c) { if ((c->final == TAM)) return(TRUE); else return(FALSE); } TipoC InfoCola(TCola *c) { if (!VaciaCola(c)) return (c->info[c->frente]); } void AdicCola(TCola *c, TipoC dato) { if (!LlenaCola( *c)) c->info[c->final++] = dato; } void ElimCola(TCola *c){ if (!VaciaCola(c)) c->frente++; }

La estructura de datos y funciones para representar las colas por el mtodo 2 se muestran a continuacin: #include <stdio.h> #include <alloc.h> #include <conio.h> #define TAM 20 #define TRUE 1 #define FALSO 0 typedef int TipoC; typedef struct { TipoC info[TAM]; int frente, final; }TCola; TCola *InicCola() { TCola *c = (TCola *) malloc (sizeof(TCola)); c->final = 0; c->frente = 0; return(c); } int VaciaCola(TCola *c){ if ((c->final == 0)) return(TRUE); else return(FALSE); } int LlenaCola(TCola *c) { if ((c->final == TAM)) return(TRUE); else return(FALSE); } TipoC InfoCola(TCola *c) { if (!VaciaCola(c)) return (c.elementos[c.frente]); } void AdicCola(TCola *c, TipoC dato) { if (!LlenaCola(c)) c->info[c->final++] = dato; } void ElimCola(TCola *c) { int i=0; if (!VaciaCola(c)) { while (i < c->final-1) c->info[i] = c->info[i+1]; c->final--; } }