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

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

Recorrido a la Izquierda

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

Algoritmo para insertar

Antes de x

Despus 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

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

Lomo Mignon

Championes 7

Carne

Tocino 1

Asado Alemn

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

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

pop

Operaciones en Pilas
Tipo
Operacin
Constructora
Modificadora

Operacin

Dominio

Codominio

Especificacin

Descripcin

InicPila
AdicPila

Modificadora

ElimPila

Pila,
TipoP
Pila

Pila
Pila
Pila

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

Pila

TipoP

TipoP InfoPila (Pila *p)

VaciaPila

Pila

int

int VaciaPila(Pila *p)

Analizadora

LlenaPila

Pila

int

int LlenaPila(Pila *p)

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

Analizadora

InfoPila

Analizadora

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

Operacin

Modificadora

InicCola
AdicCola

Dominio

Codominio

Especificacin

Descripcin

Cola
Cola

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

ElimCola

Cola,
TipoC
Cola

Cola

Cola*InicCola(void)
void AdicCola (Cola *p,
TipoC dato)
void ElimCola (Cola *c)

Analizadora

InfoCola

Cola

TipoC

TipoC InfoCola (Cola *c)

Analizadora

VaciaCola

Cola

int

int VaciaCola(Cola *c)

Analizadora

LlenaCola

Cola

int

int LlenaCola(Cola *c)

Destructora

DestruirCola

Cola

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--; }
}