Vous êtes sur la page 1sur 5

1

Estructura de Datos y Algoritmos

Universidad Nacional del Altiplano


Ingeniera de sistemas
Resolucin del examen
Nombre: Chipana Paricela Jhak thiago

1. Suponga que se tiene implementada la clase Bipila, donde la clase administra


internamente dos pilas dos pilas A y B utilizando un nico arreglo con sus respectivas
funciones dentro de una nica clase (Bipila). Cada pila interna tiene sus respectivas
funciones de administracin de datos, en el caso de la insercin son:
InsertarPilaA(char dato) e InsertarPilaB(char dato), los cuales deben indicar
respectivamente Pila A llena PilaB llena cuando todas las celdas del arreglo estn
ocupadas (insercin infructuosa). La funcin de extraccin debe indicar PilaA vaca
PilaB vaca, si y solo si, no hay datos para extraer en la pila respectiva (similar a la
pila estndar). En el arreglo, la PilaA inicia desde posicin 0 del arreglo (la izquierda) y
se desplaza hacia las posiciones superiores (la derecha), y la PilaB inicia de la ultima
celda del arreglo (posicin MAX_ELE-1) y avanza con destino a la posicin cero del
arreglo (la Izquierda).
a) Aadir a la clase Bipila la funcin miembro: bool EtsaVacia(), que retorna verdadero
(true) si la pilaB esta vaca y retorna falso en caso contrario.
b) Implementar la funcin miembro: bool EstaLlena(); que retorna verdadero (true) si la
pilaB esta llena y retorna falso en caso contrario.

Resolucin de Pila
#include <iostream>
#define MAX_ELEM 5
using namespace std;
class Bipila{
char mElementos[MAX_ELEM];
int mTopeA,mTopeB;
public:
Bipila();
/**Para la pila A*/
void InsertarPilaA(char dato);
char ExtraerPilaA();
bool EstaVaciaPilaA();
/**Para la pila B*/
void InsertarPilaB(char dato);
char ExtraerPilaB();
bool EstaVaciaPilaB();
bool EstaLlenaPilaB();
};

2
Estructura de Datos y Algoritmos

Bipila::Bipila(){
mTopeA=-1;
mTopeB=MAX_ELEM;
}
void Bipila::InsertarPilaA(char dato){
if(mTopeA+1==mTopeB)
cout<<"La PilaA esta Llena\n";
else{
mTopeA++;
mElementos[mTopeA]=dato;
cout<<"Usted ha insertado en la PilaA "<<mElementos[mTopeA]<<endl;
}
}
char Bipila::ExtraerPilaA(){
char dat;
if(mTopeA==-1)
cout<<"La PilaA esta Vacia\n";
else{
dat=mElementos[mTopeA];
mTopeA--;
cout<<"Usted a Extraido de la PilaA "<<dat<<endl;
return dat;
}
}
bool Bipila::EstaVaciaPilaA(){
if(mTopeA<=-1)
return true;
else
false;
}
void Bipila::InsertarPilaB(char dato){
if(mTopeA+1==mTopeB)
cout<<"La pilaB esta llena\n";
else{
mTopeB--;
mElementos[mTopeB]=dato;
cout<<"Usted hha insertado en la PilaB "<<mElementos[mTopeB]<<endl;
}
}
char Bipila::ExtraerPilaB(){
char da;
if(mTopeB>=MAX_ELEM)
cout<<"La PilaB esta Vacia\n";
else{
da=mElementos[mTopeB];
mTopeB++;
cout<<"Usted a EXtraido de la pilaB "<<da<<endl;

3
Estructura de Datos y Algoritmos

}
}
bool Bipila::EstaVaciaPilaB(){
if(mTopeB>=MAX_ELEM)
return true;
else
return false;
}
bool Bipila::EstaLlenaPilaB(){
if(mTopeA+1==mTopeB)
return true;
else
return false;
}
int main()
{
Bipila pila;
pila.InsertarPilaA('C');
pila.ExtraerPilaA();
pila.ExtraerPilaA();
pila.InsertarPilaB('O');
pila.InsertarPilaB('R');
pila.InsertarPilaB('R');
pila.InsertarPilaB('A');
pila.InsertarPilaB('C');
pila.InsertarPilaB('R');
pila.InsertarPilaA('B');
return 0;
}

2. Implemente la clase cola para el almacenamiento de nmeros enteros (int) con sus
funciones usuales: Insertar, Extraer, EstaVacia y EstaLlena, y con la misma estrategia
de administracin circular de datos, no obstante, se requiere que la insercin y
extraccin se efecte iniciando desde la primera desde la ltima posicin del arreglo
(mElementos[MAX_ELE-1]) avanzando a la primera posicin (mElementos[0]), es decir
en sentido inverso al estudiado. No se debe emitir mensajes de error: en caso de la
insercin si no hay espacio en la cola (desbordamiento) simplemente no se inserta el
elemento ni se emite error; en caso de la extraccin, cuando la cola esta vacia no se
extrae ningn elemento en su lugar se retorna cero y tambin no se emite error.

Resolucin de cola
#include <iostream>
#define MAX_ELEMENT 3
using namespace std;
class Cola{

4
Estructura de Datos y Algoritmos

int contenido[MAX_ELEMENT];
int cabeza,ultimo,cantidad;
public:
Cola();
void insertar(int dat);
int extraer();
bool estaVacia();
bool estaLlena();
};
Cola::Cola(){
cabeza=MAX_ELEMENT-1;
ultimo=MAX_ELEMENT;
cantidad=0;
}

void Cola::insertar(int dat){


if(cantidad>=MAX_ELEMENT)
cout<<"La cola esta llena\n";
else{
if(ultimo==0){
ultimo=MAX_ELEMENT-1;
cantidad++;
contenido[ultimo]=dat;
cout<<"Usted ha insertado "<<contenido[ultimo]<<endl;
}
else{
ultimo--;
cantidad++;
contenido[ultimo]=dat;
cout<<"Usted a insertado "<<contenido[ultimo]<<endl;
}
}
}
bool Cola::estaVacia(){
if(cantidad<=0)
return true;
else return false;
}
bool Cola::estaLlena(){
if(cantidad>=MAX_ELEMENT)
return true;
else
return false;
}
int Cola::extraer(){
int dato;
if(cantidad<=0)

5
Estructura de Datos y Algoritmos

cout<<"La cola esta Vacia\n";


else{
if(cabeza==-1){
cabeza=MAX_ELEMENT-1;
dato=contenido[cabeza];
cantidad--;
cabeza--;
cout<<"Usted ha extraido "<<dato<<endl;
return dato;
}
else{
dato=contenido[cabeza];
cabeza--;
cantidad--;
cout<<"Usted hha extraido "<<dato<<endl;
return dato;
}
}
}
int main()
{
Cola col;
col.insertar(2);
col.insertar(3);
col.insertar(7);
col.insertar(0);
col.extraer();
col.insertar(8);
col.extraer();
col.extraer();
col.insertar(4);
col.extraer();
col.extraer();
col.extraer();
return 0;
}