Académique Documents
Professionnel Documents
Culture Documents
10.1 PILAS
Una pila (stak) es una estructura de datos, que consta de una serie de datos, en la
cual las inserciones y eliminaciones se hacen por un extremo, llamado la cima (top), de la
pila. La estructura pila se conoce también como LIFO (last-in, first-out, último en entrar,
primero en salir), que significa "último elemento introducido, primero sacado". Las
operaciones fundamentales de añadir y quitar elementos de la pila se hacen por un extremo
de pila llamado cima.
El concepto de pila, desde el punto de vista informático, es similar al concepto de
pila en el mundo real: una pila de platos, una pila de libros, etc.; en estas pilas los
elementos (platos, libros, etc.) sólo pueden añadirse por un extremo (la parte superior o
cima), y sólo pueden quitarse por ese mismo extremo.
E
D
C
B
A
230
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Procedimientos
Crear (Pila): {crea-inicializa-limpia una pila vacía}
Meter (Pila, Elemento): {mete Elemento en Pila}
Sacar (Pila, Elemento): {sacar Elemento en Pila}
Función
Pila Vacía (Pila) {determina si Pila está vacía}
Pila Llena (Pila) {determina si Pila está llena}
Pese a la similitud, es preciso notar que una pila no es igual que un vector. Una pila
es, por esencia, un objeto dinámico, mientras que un vector tiene un número máximo de
elementos, determinados por su definición; no es, pues, más que una representación de la
noción abstracta.
La estructura pila se realiza con un vector, cuyo índice representa el rango de un
elemento de la pila. Las operaciones fundamentales sobre la pila se representan a
continuación - mediante procedimientos y funciones - considerando un tipo de dato Tipo
Pila.
231
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Las operaciones Pila Llena y Pila Vacía devuelven "true" si la pila está llena o
vacía, y "false" en caso contrario. En general, antes de realizar una operación en una pila se
deberán evaluar las situaciones anteriores mediante las sentencias:
Antes de sacar un elemento x de la Pila
1. if not PilaVacía (Pila) then
Sacar (Pila, X)
else {mensaje de error al usuario}
{tratamiento del mismo}
Un array es una estructura de datos muy eficiente para la implementación de una pila. La
implementación es muy sencilla:
Crear una clase Pila y utilizar esa clase para invertir un flujo de enteros.
1. Mediante una estructura estática.
2. Mediante una estructura dinámica.
232
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
pila::pila( )
{
Cuenta = 0; //inicializa la pila
}
void pila::meter(int item) //añadir un elemento a pila
{
items[cuenta++] = item;
}
void pila::sacar( ) //quitar el elemento superior de la pila
{
cuenta--;
}
#include <iostream.h>
main( )
{
pila s;
int i; // crea una pila
while(cin >> i)
s.meter(i);
if(!cin.eof( )) return 1;
233
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Una versión mejorada de la clase Pila, se realizará definiendo una nueva clase mediante
asignación dinámica del array items. Los campos son diferentes: items es ahora un puntero
y se ha añadido un campo adicional longitud que almacena el tamaño de una pila dada.
Otra diferencia es que se ha cambiado el prototipo del constructor. Ahora tiene un
argumento opcional. El último cambio es que se ha añadido un prototipo para un destructor;
se necesita liberar el espacio asignado dinámicamente al constructor.
El listado siguiente contiene las operaciones revisadas de pila, aunque la mayoría son
similares. meter rechaza añadir a una pila llena, sacar rechaza quitar de una pila vacía y
cima devuelve cero si la pila estaba vacía. Se ha modificado el constructor para asignar
dinámicamente la pila utilizando new y el destructor libera un espacio utilizando delete. No
se puede llamar al destructor directamente, se llama automáticamente siempre que se sale
del bloque en que se ha creado una pila.
class pila
{
int cuenta; // número de elementos de la pila
int *items; // pila
int longitud; // tamaño de la pila
public:
pila(int n= MAXPILA); // crear pila
pila( ); // liberar pila
void meter(int item); // añadir elemento a la pila
void sacar( ); // quitar elemento de la pila
int cima( ); // devuelve elemento superior de la pila
int esvacia( ); // ¿está la pila vacía?
};
pila :: pila(int n)
{
items = new int[n]; // crea pila
cuenta = 0; // inicializa pila a vacía
longitud = n; // elementos en la pila
}
234
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
pila :: pila( )
{
delete [ ] items;
}
void pila :: meter(int item) // añadir elemento a la pila
{
if(cuenta < longitud)
items[cuenta++] = item;
}
void pila :: quitar( ) // quitar elemento a la pila
{
if(cuenta != 0)
cuenta--;
}
235
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
10.2 COLAS
Una cola (queue en inglés) es una estructura de datos lineal en la cual la inserción de
datos se realiza por uno de sus extremos, mientras que la extracción de datos se realiza por el
otro. De esta forma, se extrae siempre el elemento que más tiempo lleve dentro de la cola. Por ello,
una cola es una estructura FIFO (First In First Out).
Las operaciones principales en una cola son la de inserción y extracción de datos, llamadas
encolar (enqueue) y desencolar (dequeue).
236
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Ejemplo :
Operaciones básicas en una cola de cuatro elementos.
CrearCola(Q)
Insertar(Q,a) a
Insertar(Q,b) a b
Insertar(Q,c) a b c
Insertar(Q,d) a b c d
Una cola es una estructura de datos adecuada para almacenar elementos que se
deben procesar en el orden que son generados.
Las colas se utilizan con frecuencia en los sistemas informáticos, siempre que más
de un proceso requiera un recurso específico, tal como una impresora, una unidad de disco
o la unidad central de proceso. Tales procesos, al solicitar un recurso específico, se sitúan
en una cola a la espera de atender a ese recurso. Por ejemplo, diferentes computadoras
pueden compartir la misma impresora, y una cola spool se utiliza para planificar las
diferentes salidas.
Si una petición para un trabajo de impresión se realiza y la impresora está libre, se le
asigna inmediatamente ese trabajo. Mientras esta salida se está imprimiendo, otras tareas
pueden necesitar la impresora. Se sitúan en una cola de tipo spool para esperar su turno.
Cuando la salida del trabajo actual termina, la impresora se libera de ese trabajo y se
asigna a la primera tarea de la cola.
Otro uso importante de las colas en un sistema informático es para operaciones de
acoplamiento o adaptación de entrada/salida (imput/output buffering). La transferencia
de información, desde un dispositivo de entrada/salida, es una operación relativamente
lenta, y el proceso de un programa debe ser suspendido mientras se transfieran los datos, la
ejecución del programa se ralentiza drásticamente. Una solución frecuente a este problema
utiliza secciones de memoria principal conocidas como memorias intermedias (buffers) y
transfiere datos entre el programa y estas memorias intermedias, en lugar de entre el
programa y el dispositivo de entrada/salida directamente.
En particular, considérese el problema en el cual los datos procesados por un
programa se leen de un archivo de disco. Esta información se transfiere desde el archivo de
disco hasta una memoria intermedia de entrada en memoria principal mientras que la
unidad central de proceso (CPU) esta ejecutando alguna otra cosa. Cuando el programa
necesita de datos, se recuperan los siguientes valores almacenados en la memoria
intermedia. Mientras estos valores se están procesando, se pueden transferir valores de
datos adicionales desde el archivo del disco hasta la memoria intermedia. La memoria
intermedia (buffer) debe ser organizada como una estructura primero en entrar primero en
salir, es decir, una cola. Una condición de cola vacía indica que la memoria intermedia esta
237
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
vacía y la ejecución del programa se suspende mientras el sistema operativo intenta cargar
más datos en la memoria intermedia o señala el fin de la entrada. Naturalmente, tal
memoria intermedia tiene un tamaño limitado, y por consiguiente una condición de cola
llena se debe utilizar para indicar cuando la memoria intermedia está llena y ningún dato
más se tiene que transferir desde el archivo de disco hasta la misma.
Las operaciones de inserción y borrado en una cola son operaciones en las que las
inserciones se realizan por un extremo y la eliminaciones (borrados) por otro. En algunas
aplicaciones es necesario que las inserciones y eliminaciones se realicen en ambos
extremos. Una estructura tipo cola en que las inserciones y eliminaciones se realicen en
cualquiera de los extremos se llama bicola (deque, "doubleended stack").
frente final
Borrado inserción
Inserción Borrado
// Programacion Avanzada
#include <iostream.h>
// Clase cola
class Cola
{
int c[100];
int e,s;
int tamanio;
public:
void inicia (void);
void pondato_cola (int i);
int sacadato_cola (void);
void pon_tamanio(int t){tamanio =t;}
};
/*Definicion de metodos */
void Cola::inicia(void)
{
e=s=0;
};
void Cola::pondato_cola(int i)
238
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
{
if (e == tamanio) {
cout << " La cola esta llena \n";
return;
}
c[e++]=i;
};
int Cola::sacadato_cola(void)
{
if (e == s) {
cout << " La cola esta vacia ";
return 0;
}
return c[s++];
};
Final =4
70 80 30
Frente =1
239
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Final = 4
30
Frente=3
Final = 7
30 110 60 40
Frente= 3
Como la cola ya está llena, antes de poder insertar otro elemento en la cola, los
elementos de array se deben desplazar de nuevo al principio del array.
Final = 5
30 110 60 40
Frente = 3
class Cola{
Int Frente, Final ;
TipoElemento Elemento[100];
Cola ( );
int ColaVacia ( );
int ColaLlena ()
void Insertar ();
void Borrar ()
};
Final=4
30 75 55
Frente=1
240
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Frente=0
4
0
insertar 50 50
insertar 40
insertar 30 1 40 3 final =3
30
2
4
0
Eliminar
Eliminar
1 3 final =3
30
2 frente= 2
Final=0
4
0 55
insertar 75
insertar 55 75
1 3
30
2 frente =2
0
1
2
Final Frente
241
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
Las operaciones básicas sobre las colas se realizarán, al igual que en el caso de las
pilas con subprogramas.
Cola::Cola ( );
(crea uan cola vacía con cero elementos)
{ {CrearCola}
Frente = 0 {inicializa puntero Frente y Final}
Final = 0
}
int Cola::ColaVacia ( )
{el valor de la función es true si la cola esta vacía}
{false en caso contrario}
{
return(.Frente = Final);
}
int Cola::ColaLlena ()
{devuelve true si la cola está llena; false en caso contrario}
Int Siguiente;
{localizar siguiente posición disponible}
if Final = MaxCola then
Siguiente: = Final+1;
Siguiente = Q.Final
return(siguiente);
}
void Cola:: Insertar ();
{//añade item al final de la lista; se supone que la cola no esta llena
void Cola::Borrar ()
{//recuperar Item y borrarlo del principio de la cola, suponiendo que la cola noe este vacia
242
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
If (!ColaVacia() )
{
Item = Elementos [Frente];
Frente = (Frente +1) mod MaxCola
}
243
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
int t=P1.tope;
for (int i=0;i<t;i++)
this.push(P1.pop());
import javax.swing.*;
public class cola
{
int entrada, salida,tam;
String C[]= new String[100];
public cola(int t)
{
tam=t;
entrada=salida=0;
}
public void insertar(String dato)
{
C[entrada]=dato;
entrada++;
}
public String extraer()
{
String n;
n=C[salida];
salida++;
return (n);
}
public int vacia()
{
if(entrada==salida) return 1;
else return 0;
}
244
BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA
Facultad de Ciencias de la Computación
245