Sie sind auf Seite 1von 6

Facultad de Ingeniería

Escuela de Computación
Análisis de Algoritmo

Por:
Manuel Torres Rivas
26.561.400
Profesora: Ing. Tania Segnini

Ejercicios sobre estructura de datos

Lenguaje utilizado C++


 Ejercicio 1:

Se desea tener una aplicación que permita registrar las solicitudes de una tienda
que solo atiende a clientes vía correo electrónico. Los pedidos que llegan deben
tener un cliente, dirección - zona y una lista de objetos que se piden y cada objeto
debería tener un peso que defina su posibilidad de atención y en base a la suma de
los pesos de todos los objetos de los pedidos, se define el orden de atención de estos
pedidos. Los pedidos jamás pesan 100 puntos y lo mínimo que pesan es 10 puntos,
las solicitudes se organizan de acuerdo al peso que tienen, del 10 al 19, del 20 al 29,
y así sucesivamente del 90 al 99. Cada vez que se atiende el pedido, se debe a su vez
registrar el pedido de acuerdo a la dirección del cliente. Al finalizar el día, la tienda
genera un listado que tiene los pedidos organizados por dirección - zona, de forma
tal que al día siguiente su personal de reparto se haga cargo de la entrega de un
conjunto de pedidos; asimismo, se sabe que el personal de reparto se divide el
trabajo por zonas.
 Estructura(s) de datos.

Se utilizaran listas simples, una para los clientes y por cada cliente un alista de sus
pedidos.
struct ListaObjetos{
char[20] Objeto;
int Peso;
struct ListaObjetos *sgte;
}
typedef struct ListaObjetos *Tlista;
}
struct Clientes{

int nro; // numero de cliente


char[20] dirección; // dirección de cliente
int zona; // zona de entrega a la que pertenece el
cliente
struct Clientes *sgte;
};
typedef struct Clientes *Tlista;

 Descripción de la estructura de los elementos de la Cola/Lista.

Estructura de los objetos del pedido ListaObjetos


Contiene:
Objeto char[20]
Peso int
ListaObjetos *sgte

Estructura para los Clientes


Contiene:
nro int numero de cliente
dirección char[20] dirección de cliente
zona int zona de entrega a la que pertenece el cliente
Pesos int lista de pedidos
Clientes *sgte;

 Método(s) necesario(s) para el requerimiento de un cliente y


registrarlo para su posterior entrega.
void RegistraCliente(Tlista &lista, int valor, char direc, int zon,
int contador)
{
Tlista q;
q = new(struct Clientes);
q->nro = valor;
q->direccion = direc;
q->zona = zon;
q->pesos = contador;

q->sgte = lista;
lista = q;
while(contador > 0)
{
// leer un peso P1
Tlista p;
p = new(struct ListaObjetos);
p->peso = P1;
p->sgte = ListaObjetos;
ListaObjetos = q;
}
}

 Método(s) necesario(s) para encontrar la lista y planificación de las


entregas diarias.
Void OrdenarPedidos (Contador)
{
int i, Tope=contador;
float *v=new float[Tope];
Nodo *P=ListaObjetos;
for (i=0; i<Tope && P;i++)
{
v[i]=P->peso;
P=P->sgte;
}
P=ListaObjetos;
for (int i=0; i<contador && P;i++)
{
P->peso = v[i];
P=P->sgte;
}
delete []v;
return(ListaObjetos);

void GenerarPedidos(Tlista lista)


{
int i = 0;
while(lista != NULL)
{

cout <<' '<< i+1 <<") " << lista->nro << endl;
lista = lista->sgte;

i++;
}
}
 Ejercicio 2:

Se desea controlar la ejecución de un programa de manera que se tenga un reporte


exhaustivo de las ejecuciones de los procesos que contiene el programa. De estas
ejecuciones, se requiere el nombre del proceso. En caso de que exista un error se
debería informar con propiedad en que parte ocurrió el error y todo el camino que
ha afectado.

Por ejemplo, si se tiene el La ejecución correcta del mismo La salida sería:


siguiente programa: debería generar un seguimiento así:
prog1
SUCCESSFULL
proc1
prog1 iniciado
proc2
proc4
proc1 iniciado Pero una ejecución fallida
proc2 proc2 iniciado por ejemplo si el proc2
proc5 proc2 terminado
proc8 proc4 iniciado
falla en la segunda
proc2 iniciado llamada, el seguimiento
fin prog1 proc2 terminado debería ser así:
proc5 iniciado
prog1 iniciado
proc5 terminado
proc1 iniciado
proc4 terminado proc2 iniciado
proc8 iniciado proc2
proc8 terminado terminado
proc4 iniciado
prog1 terminado proc2 iniciado
proc2 fallado
proc4 fallado

prog1 fallado

La salida sería: ABORT ERROR prog1:proc4:proc2


 Estructura de datos
Se elige trabajar con una Cola, ya que podemos trabajar con el esquema FIFO, donde
se almacenan los Programas en orden de aparición, también se almacena la
instrucción de final como booleana (TRUE Finaliza) (FALSE Error)

 Estructura de los elementos que contendrá la COLA.

Elementos: es la Cola y contiene los siguientes elementos:


Elementos *next Proximo Programa
Programa char Nombre del elemento
estado Boolean instrucción de final (TRUE Finaliza) (FALSE Error)
 Métodos para realizar seguimiento a la ejecución de un programa

typedef struct Elementos


{
struct Elementos *next; //Proximo elemento
char Programa;//Nombre del elemento
Boolean estado;
}Elementos;

Element *first=NULL; //primer elemento


Element *last=NULL; // ultimo elemento

//Crear la Cola
void creaCola(Elementos *_Elementos, int Proceso, boolean estatus)
{
//Se le asigna un proceso al nuevo elemento
_Elementos->Programa=Proceso;
_Elementos->estado=estatus;
}

//Meter en la Cola
void PUSH(Elementos *_Elementos)
{
_Elementos->next=NULL;
//Si el primero no existe quiere decir que no hay nada en la cola y
esta vacia
if(first==NULL){
first=_Elementos; //El primer programa será el nuevo elemento
creado
last=_Elementos; //Y también será el último dado que solo existe
uno en la

cola
}
else{
//Si no
last->next=_Elementos;
last=_Elementos;
}
}

Elementos * POP()
{
if(first==NULL)
return NULL;
Elementos * _Elementos_Return=first;
first=first->next;
return _Elementos_Return;
}

//Desencolar e indicar salida o resultado


void Salida()
{
//Obtiene el primer elemento de la cola
Elementos *i=pop();
while(i)
{
if( i->not(estado) {
printf("%i\n",” ABORT ERROR”, i->Programa );
return
}
i=pop();
}
printf("%i\n",” SUCCESSFULL” );
}

int main ()
{
Elementos *_Elementos;
creaCola(_Elementos,1);
push(_Elementos);
Salida();
return 0;
}