Carrera Ingeniera en Sistemas

Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 1 de 8

#include <iostream>
#include <assert.h>
using namespace std;
/************************************************************************************************************************
Ejercicio 1
*************************************************************************************************************************
Considere la siguiente declaracin en C++ del tipo de rboles binarios de enteros:
typedef struct nodoAB* AB;
struct nodoAB
{
int dato;
AB izq;
AB der;
};

Desarrolle una funcin
void muestro (AB raiz,int nivelDesde, int nivelHasta, int valorDesde, int valorHasta)
que recibe un rbol binario ordenado y muestra los elementos que se encuentran ubicados en los niveles del
rbol comprendidos entre nivelDesde y nivelHasta inclusive y cuyos datos se encuentre comprendidos entre los
valores valorDesde y valorHasta inclusive ordenado en forma descendente. Puede usar funciones auxiliares
pero deber implementarlas. Se define que el nivel de la raz del rbol es 1.
La salida debe tener el formato
COMIENZO RBOL
----
----
----
FIN RBOL
Para que se muestre una sola vez comienzo rbol y fin rbol y para manejar con sencillez
el nivel actual es conveniente usar una funcin auxiliar
*/
typedef struct nodoAB* AB;
struct nodoAB
{
int dato;
AB izq;
AB der;
};
bool esVacio(AB raiz)
{
return raiz == NULL;
};
void muestro (AB raiz,int nivelDesde, int nivelHasta, int valorDesde, int valorHasta, int nivelActual)
{
if(!esVacio(raiz) && nivelHasta>=nivelActual)
{
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 2 de 8

muestro(raiz->der,nivelDesde,nivelHasta,valorDesde,valorHasta,nivelActual+1);
if(raiz->dato >= valorDesde && raiz->dato
<= valorHasta && nivelDesde >=nivelActual) cout << endl << raiz->dato<< endl;
muestro(raiz->izq,nivelDesde,nivelHasta,valorDesde,valorHasta,nivelActual+1);
};
};

void muestro (AB raiz,int nivelDesde, int nivelHasta, int valorDesde, int valorHasta)
{
cout << endl << "COMIENZO RBOL"<< endl;
muestro(raiz,nivelDesde,nivelHasta,valorDesde,valorHasta,1);
cout << endl << "COMIENZO RBOL"<< endl;
};

/********************************************************************************************************
Ejercicio 2
*********************************************************************************************************
1. Especifique, con pre y pos condiciones, el TAD MultiSet no acotado de enteros
que toman valores en el intervalo [0..m].
Considere las operaciones:
Empty(m): construye el MultiSet vaco.
IsEmpty: retorna true si, y slo si, el MultiSet no contiene elementos.
Insert(x, n): agrega n ocurrencias del elemento x al MultiSet.
Delete(x, n): elimina a lo sumo n ocurrencias del elemento x del MultiSet.
NroOcurr(x): retorna el nmero de ocurrencias del elemento x en el MultiSet.
2. Desarrolle una implementacin en la cual todas las operaciones excepto la
que vaca el MultiSet y las constructoras sean de O(1) peor caso.
====================================================
1 ESPECIFICACION
====================================================
Notar que se trata de un TAD que no es genrico ya que es de enteros
pero estos enteros toman valores en un intervalo
*/
class MultiSet
{
public:
virtual ~MultiSet(){};
virtual MultiSet& Empty(int m) const abstract;
//pre:
//pos: construye el MultiSet vaco.
virtual bool IsEmpty() const abstract;
//pre:
//pos retorna true si, y slo si, el MultiSet no contiene elementos.
virtual void Insert(int x, int n) abstract;
//pre: 0<= x <=m
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 3 de 8

//pos: agrega n ocurrencias del elemento x al MultiSet.
virtual void Delete(int x, int n) abstract;
//pre: 0<= x <=m
//pos: elimina a lo sumo n ocurrencias del elemento x del MultiSet.
virtual int NroOcurr(int x) const abstract;
//pre: 0<= x <=m
//pos: retorna el nmero de ocurrencias del elemento x en el MultiSet.
virtual int valorMaximo() const abstract;
//pre
//pos retorna el valor m'aximo que toman los elementos del MultiSet
};
/*============================================================
2. Desarrolle una implementacin en la cual todas las operaciones excepto la
que vaca el MultiSet sean de O(1) peor caso.
=============================================================
*/
class MultiSetImp :public MultiSet
{
public:
virtual ~MultiSetImp(){delete elementos;};
MultiSetImp(unsigned int m);
virtual MultiSet& Empty(int m) const;
//pre:
//pos: construye el MultiSet vaco.
virtual bool IsEmpty() const;
//pre:
//pos retorna true si, y slo si, el MultiSet no contiene elementos.
virtual void Insert(int x, int n);
//pre: 0<= x <=m
//pos: agrega n ocurrencias del elemento x al MultiSet.
virtual void Delete(int x, int n);
//pre: 0<= x <=m
//pos: elimina a lo sumo n ocurrencias del elemento x del MultiSet.
virtual int NroOcurr(int x) const;
//pre: 0<= x <=m
//pos: retorna el nmero de ocurrencias del elemento x en el MultiSet.
virtual int valorMaximo() const
//pre
//pos retorna el valor m'aximo que toman los elementos del MultiSet
{
return maxValor;
};
private:
int * elementos;
int cantElementos;
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 4 de 8

int maxValor;
MultiSetImp();//para evitar que se construya un MultiSet sin declarar
// el valor mximo que toman los elementos
};
MultiSetImp::MultiSetImp(unsigned int m)
{
assert(m>0);
cantElementos=0;
maxValor=m;
elementos=new int[maxValor+1];
for(int i=0;i<=maxValor;i++)
elementos[i]=0;
assert(elementos);

};
MultiSet& MultiSetImp::Empty(int m) const
//pre:
//pos: construye el MultiSet vaco.
{
return *new MultiSetImp(m);
};
bool MultiSetImp::IsEmpty() const
//pre:
//pos retorna true si, y slo si, el MultiSet no contiene elementos.
{
return cantElementos==0;
};
void MultiSetImp::Insert(int x, int n)
//pre: 0<= x <=m
//pos: agrega n ocurrencias del elemento x al MultiSet.
{
assert(x>=0 && x<=maxValor);
assert(n>=0);
elementos[x]=elementos[x]+n;
cantElementos=cantElementos+n;
};
void MultiSetImp::Delete(int x, int n)
//pre: 0<= x <=m
//pos: elimina a lo sumo n ocurrencias del elemento x del MultiSet.
{
assert(x>=0 && x<=maxValor);
if(elementos[x] < n)
{
cantElementos=cantElementos-elementos[x];
elementos[x]=0;
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 5 de 8

}
else
{
cantElementos=cantElementos-n;
elementos[x]=elementos[x]-n;
};
};
int MultiSetImp::NroOcurr(int x) const
//pre: 0<= x <=m
//pos: retorna el nmero de ocurrencias del elemento x en el MultiSet.
{
assert(x>=0 && x<=maxValor);
return elementos[x];

};

/************************************************************************************************************
EJERCICIO 3
************************************************************************************************************
Ejercicio 3
1. Especifique, con pre y pos condiciones, el TAD Diccionario no acotado de enteros que
toman valores en el intervalo [0..m]. Considere las operaciones:
agregar(int e) agrega e si el mismo no estaba en el diccionario,
en caso contrario no hace nada.
vacio(int m) crea el diccionario vaco
eliminar(int e) borra "e" si el mismo estaba en el diccionario,
en caso contrario no hace nada
esVacio() retorna true si el diccionario es vaco y false en caso contrario.
esMiembro(const Etype& e) Retorna true si "e" se encuentra en el diccionario,
en caso contrario retorna false.
valorMaximo() retorna el valor mximo m que toman los elementos del diccionario
2. Desarrolle una implementacin en la cual todas las operaciones
excepto la que vaca el Diccionario y las constructoras sean de O(1) peor caso.
3. Desarrolle una funcin bool estaContenido(const Diccionario & d1, const Diccionario & d2) que retorna
true si y solo si d1 esta contenido en d2.
4. Desarrolle una funcin bool sonIguales(const Diccionario & d1, const Diccionario & d2) que retorna true
si y solo si d1 y d2 son iguales.
====================================================================
1 ESPECIFICACIN
====================================================================
*/
class Diccionario
{
public:
virtual void agregar(int e) abstract;
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 6 de 8

//pre
//pos agrega e si el mismo no estaba en el diccionario,
//en caso contrario no hace nada.
virtual Diccionario& vacio(int m)const abstract;
//pre
//pos crea el diccionario vaco
virtual void eliminar(int e) abstract;
//pre
//pos borra "e" si el mismo estaba en el diccionario,
//en caso contrario no hace nada
virtual bool esVacio() const abstract;
//pre
//pos retorna true si el diccionario es vaco y false en caso contrario.
virtual bool esMiembro(const int e) const abstract;
//pre
//pos Retorna true si "e" se encuentra en el diccionario,
//en caso contrario retorna false.
virtual int valorMaximo() const abstract;
//pre
//pos retorna el valor mximo m que toman los elementos del diccionario
};
/*==========================================================

2. Desarrolle una implementacin en la cual todas las operaciones
excepto la que vaca el Diccionario y las constructoras sean de O(1) peor caso.
=============================================================
*/
class DiccionarioImpMultiSet :public Diccionario
{
public:
virtual ~DiccionarioImpMultiSet()
{
delete multiset;
};
DiccionarioImpMultiSet(int m)
{
multiset=new MultiSetImp(m);
};
virtual void agregar(int e)
//pre
//pos agrega e si el mismo no estaba en el diccionario,
//en caso contrario no hace nada.
{
multiset->Insert(e,1);
};
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 7 de 8

virtual Diccionario& vacio(int m)const
//pre
//pos crea el diccionario vaco
{
return * new DiccionarioImpMultiSet(m);
};
virtual void eliminar(int e)
//pre
//pos borra "e" si el mismo estaba en el diccionario,
//en caso contrario no hace nada
{
multiset->Delete(e,multiset->NroOcurr(e));
};
virtual bool esVacio() const
//pre
//pos retorna true si el diccionario es vaco y false en caso contrario.
{
return multiset->IsEmpty();
};
virtual bool esMiembro(int e) const
//pre
//pos Retorna true si "e" se encuentra en el diccionario,
//en caso contrario retorna false.
{
return multiset->NroOcurr(e)>0;
};
virtual int valorMaximo() const
//pre
//pos retorna el valor mximo m que toman los elementos del diccionario
{
return multiset->valorMaximo();
};

private:
MultiSet * multiset;
DiccionarioImpMultiSet(){};//para impedir creacin sin establecer valor mximo
};
/*==============================================================
3. Desarrolle una funcin bool estaContenido(const Diccionario & d1, const Diccionario & d2)
que retorna true si y solo si d1 esta contenido en d2.
=================================================================
*/
bool estaContenido(const Diccionario & d1, const Diccionario & d2)
{
int maxValor1=d1.valorMaximo();
Carrera Ingeniera en Sistemas
Licenciatura en Sistemas
Examen de: Estructuras de datos y Algoritmos 1 Cdigo de materia:
Fecha: 10-02-10 Id Examen: Acta: Hoja 8 de 8

int maxValor2=d2.valorMaximo();
if(maxValor1!=maxValor2) return false;
for(int i=0;i<=maxValor1;i++)
if(d1.esMiembro(i) && !d2.esMiembro(i)) return false;
return true;

};
/*============================================================
4. Desarrolle una funcin bool sonIguales(const Diccionario & d1, const Diccionario & d2)
que retorna true si y solo si d1 y d2 son iguales.
=============================================================
*/
bool sonIguales(const Diccionario & d1, const Diccionario & d2)
{
return estaContenido(d1,d2) && estaContenido(d2,d1);
};
void main()
{};