Pilas Y colas En lenguaje C++

5/25/2018 Pilas Y colas En lenguaje C++

1/16

Repblica bolivariana de Venezuela

Ministerio del poder popular para la defensa

Universidad nacional experimental politcnica de la fuerza armada bolivariana

UNEFANcleo Zulia

Maracaibo


2/16

1) Qu es Una pila?

Una pila es una estructura de datos a la cual se puede acceder solo por un extremo de lamisma. Las operaciones de insercin y extraccin se realizan a travs del tope, por lo cualno se puede acceder a cualquier elemento de la pila. Se la suele llamar estructura L.I.F.O.como acrnimo de las palabras inglesas "last in, firstout" (ltimo en entrar, primero en

salir). La pila se considera un grupo ordenado de elementos, teniendo en cuenta que elorden de los mismos depende del tiempo que lleven "dentro" de la estructura. Las pilasson frecuentemente utilizadas en el desarrollo de sistemas informticos y software engeneral. Por ejemplo, el sistema de soporte en tiempo de compilacin y ejecucin delPascal utiliza una pila para llevar la cuenta de los parmetros de procedimientos yfunciones, variables locales, globales y dinmicas. Este tipo de estructuras tambin sonutilizadas para traducir expresiones aritmticas o cuando se quiere recordar unasecuencia de acciones u objetos en el orden inverso del ocurrido.

Pila como tipo abstracto de datos

A modo de resumen tipo de datos, la pila es un contenedor de nodos y tiene dosoperaciones bsicas: push (o apilar) y pop (o desapilar). 'Push' aade un nodo a la partesuperior de la pila, dejando por debajo el resto de los nodos. 'Pop' elimina y devuelve elactual nodo superior de la pila. Una metfora que se utiliza con frecuencia es la idea deuna pila de platos en una cafetera con muelle de pila. En esa serie, slo la primera placaes visible y accesible para el usuario, todas las dems placas permanecen ocultas. Comose aaden las nuevas placas, cada nueva placa se convierte en la parte superior de lapila, escondidos debajo de cada plato, empujando a la pila de placas. A medida que laplaca superior se elimina de la pila, la segunda placa se convierte en la parte superior dela pila. Dos principios importantes son ilustrados por esta metfora: En primer lugar laltima salida es un principio, la segunda es que el contenido de la pila est oculto. Slo laplaca de la parte superior es visible, por lo que para ver lo que hay en la tercera placa, elprimer y segundo platos tendrn que ser retirados.

2) Operaciones con pilas

Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en lasimplementaciones modernas de las pilas se suelen aadir ms de uso habitual.

Crear: se crea la pila vaca. (constructor)

Tamao: regresa el nmero de elementos de la pila. (size)

Apilar: se aade un elemento a la pila.(push)

Desapilar: se elimina el elemento frontal de la pila.(pop)

Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)

Vaca: devuelve cierto si la pila est vaca o falso en caso contrario (empty).


3/16

3) Declaracin de las pilas

Un requisito tpico de almacenamiento de una pila de n elementos es O(n). El requisitotpico de tiempo de O(1) las operaciones tambin son fciles de satisfacer con un array ocon listas enlazadas simples.

La biblioteca de plantillas de C++ estndar proporciona una "pila" clase templated que selimita a slo apilar/desapilar operaciones. Java contiene una biblioteca de la clase Pilaque es una especializacin de Vector. Esto podra ser considerado como un defecto,porque el diseo heredado get () de Vector mtodo LIFO ignora la limitacin de la Pila.

Estos son ejemplos sencillos de una pila con las operaciones descritas anteriormente(pero no hay comprobacin de errores).

Declaracin de las pilas En C++

#ifndef PILA

#define PILA // define la pila

template

classPila{

private:

structNodo{

T elemento;

Nodo* siguiente; // coloca el nodo en la segunda posicion

}*ultimo;

unsignedint elementos;

public:

Pila(){

elementos=0;

}

~Pila(){

while(elementos!=0) pop();

}

void push(const T&elem){

Nodo*aux=new Nodo;


4/16

aux->elemento =elem;

aux->siguiente = ultimo;

ultimo=aux;

++elementos;

}

void pop(){

Nodo*aux= ultimo;

ultimo= ultimo->siguiente;

deleteaux;

--elementos;

}

T cima()const{

return ultimo->elemento;

}

boolvacia()const{

returnelementos==0;

}

unsignedintaltura()const{

return elementos;

}

};

#endif


5/16

4) Que son las Colas?

Una cola es una coleccin de elementos homogneos (almacenados en dicha estructura),en la misma se pueden insertar elementos por uno de los extremos, llamado frente, yretirar los mismos por el otro extremo, denominado final.

Es importante aclarar que, tanto el frente como el final de la cola, son los nicos indicadospara retirar e insertar elementos, respectivamente. Esto nos indica que no podemosacceder directamente a cualquier elemento de la cola, sino solo al primero, o sea el queest o se encuentra en el frente, y no se pueden insertar elementos en cualquier posicinsino solo por el final, as el elemento insertado queda como ltimo.

Por esta razn la cola es denominada una estructura F.I.F.O., o simplemente una listaF.I.F.O., esto representa el acrnimo de las palabras inglesas first in, firstout (primero enentrar, primero en salir).

Para trabajar con una cola, as como para cualquier tipo de estructura abstracta,tendremos que definir las operaciones que representen el comportamiento de la misma,para de esta manera poder utilizarlas.

5) Operaciones con colas

Crear cola.

Insertar elemento.

Retirar elemento.

Cola vaca.

Vaciar cola.

Podemos definir una cola en forma dinmica implementndola como una lista simple yrespetando las restricciones de insercin (slo se puede realizar a travs del final) yextraccin (slo se puede realizar por el frente).

Operaciones Bsicas

Crear: se crea la cola vaca.

Encolar: (aadir, entrar, insertar): se aade un elemento a la cola. Se aade al finalde esta.

Desencolar: (sacar, salir, eliminar): se elimina el elemento frontal de la cola, esdecir, el primer elemento que entr.

Frente: (consultar, front): se devuelve el elemento frontal de la cola, es decir, elprimer elemento que entr.


6/16

6) Declaracion de las colas en C++

#ifndef COLA

#define COLA // Define la cola

usingnamespacestd;

template

class Cola{

private:

structNodo{

T elemento;

struct Nodo* siguiente;// coloca el nodo en la segunda posicin

}*primero;

struct Nodo* ultimo;

unsignedint elementos;

public:

Cola(){

elementos=0;

}

cout


7/16

}

void pop(){

Nodo*aux= primero;

primero= primero->siguiente;

deleteaux;

--elementos;

}

T consultar()const{

return primero->elemento;

}

boolvacia()const{

return elementos ==0;

}

unsignedint size()const{

returnelementos;

}

};

#endif

7) Pila alojada en arreglo estatico

En el programa que se ver en seguida, se simula el comportamiento de una estructurade pila. Aunque en el mismo se usa un arreglo esttico de tamao fijo se debe mencionarque normalmente las implementaciones hechas por fabricantes y/o terceras personas sebasan en listas dinmicas o enlazadas.

Para la implementacin de la clase Stack se han elegido los mtodos:

put(), poner un elemento en la pilaget(), retirar un elemento de la pilaempty(), regresa 1 (TRUE) si la pila esta vaciasize(), nmero de elementos en la pilaEl atributo SP de la clase Stack es el puntero de lectura/escritura, es decir, el SP


8/16

indica la posicin dentro de la pila en donde la funcin put() insertar el siguientedato, y la posicin dentro de la pila de donde la funcin get() leer el siguiente dato.Cada vez que put() inserta un elemento el SP se decrementa.Cada vez que get() retira un elemento el SP se incrementa.

En el siguente ejemplo se analiza lo que sucede con el SP (puntero de pila) cuando seguardan en la pila uno por uno los caracteres 'A', 'B', 'C' y 'D'. Observe que al principio elSP es igual al tamao de la pila.

Llenando la pila.

SP|

+---+---+---+---+---+| | | | | | al principio (lista vacia)+---+---+---+---+---+

SP|

+---+---+---+---+---+ push('A');| | | | | A | despus de haber agregado el primer elemento+---+---+---+---+---+

...

SP|

+---+---+---+---+---+

| | D | C | B | A | despus de haber agregado cuatro elementos+---+---+---+---+---+

Vaciando la pila.

SP|

+---+---+---+---+---+ pop();| | D | C | B | A | despus de haber retirado un elemento+---+---+---+---+---+

... SP

|+---+---+---+---+---+| | D | C | B | A | despus de haber retirado todos los elementos+---+---+---+---+---+Nota: observe que al final la lista est vacia, y que dicho estado se debe a queel puntero est al final de la pila y no al hecho de borrar fsicamente cada elementode la pila.


9/16

Ejemplo: Pila basada en un arreglo esttico

#include using namespace std;

#define STACK_SIZE 256 /* capacidad mxima */typedef char arreglo[STACK_SIZE];

class Stack {

int sp; /* puntero de lectura/escritura */int items; /* nmero de elementos en lista */int itemsize; /* tamao del elemento */arreglo pila; /* el arreglo */

public:// constructor

Stack() {sp = STACK_SIZE-1;items = 0;itemsize = 1;

}

// destructor~Stack() {};

/* regresa el nmero de elementos en lista */int size() { return items; }

/* regresa 1 si no hay elementos en la lista, o sea, si la lista est vacia */int empty() { return items == 0; }

/* insertar elemento a la lista */int put(char d){

if ( sp >= 0) {pila[sp] = d;sp --;items ++;

}return d;

}

/* retirar elemento de la lista */int get(){

if ( ! empty() ) {sp ++;items --;

}


10/16

return pila[sp];}

}; // fin de clase Stack

// probando la pila.// Nota: obseve cmo los elementos se ingresan en orden desde la A hasta la Z,// y como los mismos se recupern en orden inverso.int main(){

int d;Stack s; // s es un objeto (instancia) de la clase Stack

// llenando la pilafor (d='A'; d


11/16

10) Ejemplo de implementacin de pilas en C++

#include using namespace std;

struct nodo{int nro;struct nodo *sgte;

};

typedef nodo *ptrPila; // creando nodo tipo puntero( tipo de dato )

/* Apilar elemento---------------------------------------------------------------------*/void push( ptrPila &p, int valor ){

ptrPila aux;aux = new(struct nodo); // apuntamos al nuevo nodo creadoaux->nro = valor;

aux->sgte = p ;p = aux ;

}

/* Desapilar elemento(devuelve elemento)---------------------------------------------------------------------*/int pop( ptrPila &p ){

int num ;ptrPila aux;

aux = p ;num = aux->nro; // asignamos el primer vamor de la pila

p = aux->sgte ;delete(aux);

returnnum;}

/* Muestra elementos de la pila---------------------------------------------------------------------*/void mostrar_pila( ptrPila p ){

ptrPila aux;aux = p; // apunta al inicio de la lista

while( aux !=NULL ){


12/16

cout


13/16

cout> dato;push( p, dato );cout


14/16

using namespace std;

/* Estructura de los nodos de la cola-----------------------------------------------------------------*/struct nodo

{int nro;struct nodo *sgte;

};

/* Estructura de la cola-----------------------------------------------------------------*/struct cola{

nodo *delante;nodo *atras ;

};

/* Encolar elemento------------------------------------------------------------------*/void encolar( struct cola &q, int valor ){

struct nodo *aux = new(struct nodo);

aux->nro = valor;aux->sgte = NULL;

if( q.delante == NULL)q.delante = aux; // encola el primero elemento

else(q.atras)->sgte = aux;

q.atras = aux; // puntero que siempre apunta al ultimo elemento

}

/* Desencolar elemento------------------------------------------------------------------*/int desencolar( struct cola &q ){

int num ;

struct nodo *aux ;

aux = q.delante; // aux apunta al inicio de la colanum = aux->nro;q.delante = (q.delante)->sgte;delete(aux); // libera memoria a donde apuntaba aux

returnnum;}


15/16

/* Mostrar Cola-------------------------------------------------------------------*/void muestraCola( struct cola q ){

struct nodo *aux;

aux = q.delante;

while( aux != NULL ){

coutsgte;delete(aux);

}q.delante = NULL;q.atras = NULL;

}/* Menu de opciones--------------------------------------------------------------------*/void menu(){

cout


16/16

q.delante = NULL;q.atras = NULL;

int dato; // numero a encolar

int op; // opcion del menuint x ; // numero que devuelve la funcon pop

system("color 0b");

do{

menu(); cin>> op;

switch(op){

case1:

cout> dato;encolar( q, dato );cout

Pilas Y colas En lenguaje C++

Documents

Transcript of Pilas Y colas En lenguaje C++