Practica5

Práctica 5:
ESTRUCTURAS DE DATOS. MEMORIA
DINÁMICA.
1. ESTRUCTURAS DE DATOS.
a) Dada la descripción de la siguiente aplicación:
Se desea informatizar la información que una universidad dispone de los
diversos departamentos que la componen. Concretamente de cada departamento
se tiene:

número de departamento (es único y debe ser proporcionado por el
programa);

nombre del departamento;

fecha (día, mes y año) de creación del departamento; y

tipo de área de estudio. Puede tener uno de los siguientes valores:
Científico, Tecnológico, Jurídico y Humanístico.
Realiza un programa estructurado que permita almacenar los datos de varios
departamentos en un vector, para posteriormente visualizarlos en pantalla. A
grandes rasgos el programa debe contener:

la declaración de una estructura de datos para almacenar toda la
información de un departamento y el vector correspondiente para
contener la información de diez departamentos (se debe tener como
objetivo el ahorro de espacio y la legibilidad de la estructura),

una función que lea del teclado la información referente a un
departamento y que devuelva la variable estructura con dicha
información;

una función que visualice la información que recibe de un departamento
en una variable estructura.
2. MEMORIA DINÁMICA.
a)
Implementa el apartado 1.a) mediante un array dinámico. El número de
departamentos será introducido por el teclado.
b)
El siguiente programa gestiona una agenda de teléfonos mediante una lista
enlazada implementada sin nodo cabecera. Dicho programa consta de tres
ficheros:
1.
Archivo cabecera correspondiente al tipo de dato abstracto lista. El
nombre de este fichero es lissin.h
#ifndef _LISSIN.H
#define _LISSIN.H
#include <iostream.h>
struct persona
{
char nombre[50];
char telefono[12];
char ciudad[20];
};
struct nodo
{
persona amigo;
nodo *sig;
};
typedef nodo * posicion;
typedef posicion lista;
void error(char *mensaje);
void insertar(lista &l, posicion p, persona per);
posicion localizar (lista l, char *nombre);
persona recuperar (lista l, posicion p);
void suprimir(lista &l, posicion p);
posicion siguiente(lista l, posicion p);
posicion anterior(lista l, posicion p);
posicion ultimo(lista l);
posicion primero (lista l);
posicion fin(lista l);
int esvacia(lista l);
void inicializar(lista &l);
#endif
2.
Archivo que contiene la implementación del tipo de dato abstracto
lista sin nodo cabecera. Su nombre es lissin.cpp
#include "lissin.h"
void error(char *mensaje)
{
cout<<mensaje; cin.get();
}
void insertar(lista &l, posicion p, persona per)
{
posicion nuevo;
if((nuevo=new nodo)!=0)
{
nuevo->amigo=per;
nuevo->sig=p;
if(p==primero(l)) l=nuevo;
else anterior(l,p)->sig=nuevo;
}
else error("\nInsertar: no hay memoria\n");
}
posicion localizar(lista l, char *nombre)
{
posicion pos;
pos=primero(l);
while((pos!=fin(l))&&(strcmp(pos->amigo.nombre, nombre)))
pos=siguiente(l,pos);
return pos;
}
persona recuperar(lista l, posicion p)
{
if((esvacia(l))||(p==fin(l)))
error("\nRecuperar: posición no existe\n");
else return p->amigo;
}
void suprimir(lista &l, posicion p)
{
if(esvacia(l)||(p==fin(l)))
error("\nSuprimir: esa posicion no existe\n");
else {
if(p==primero(l)) l=siguiente(l, p);
else anterior(l, p)->sig=siguiente(l, p);
}
delete p;
}
posicion siguiente(lista l, posicion p)
{
if(p==fin(l)) error("\nSiguiente: posicion es el fin de la lista\n");
else return p->sig;
}
posicion anterior(lista l, posicion p)
{
posicion pos;
if(p==primero(l)) error("\nAnterior: posicion es la primera\n");
else {
pos=primero(l);
while((pos!=fin(l))&&(siguiente(l, pos)!=p))
pos=siguiente(l, pos);
if(pos==fin(l))
error("\nAnterior: no existe el anterior a esa posición\n");
else return pos;
}
}
posicion primero(lista l)
{
if(esvacia(l)) return fin(l);
else return l;
}
posicion ultimo(lista l)
{
posicion pos;
if(esvacia(l)) return fin(l);
else {
pos=primero(l);
while (siguiente(l, pos)!=fin(l))
pos = siguiente(l, pos);
return pos;
}
}
posicion fin(lista l)
{
return 0;
}
int esvacia(lista l)
{
return l==0;
}
void inicializar (lista &l)
{
l=0;
}
3.
Archivo que contiene la implementación de la agenda de teléfonos
utilizando el tipo de dato abstracto lista. El nombre de este fichero es
agenda.cpp
#include "lissin.h"
int menu(void);
void leer_datos(persona &per);
void leer(lista &agenda);
void borrar(lista &agenda);
void escribir_datos(persona per);
int consultar(lista agenda);
void listar(lista agenda);
void main()
{
int op; lista agenda;
inicializar(agenda);
do
{
op=menu();
switch(op)
{
case 1: leer(agenda); break;
case 2: borrar(agenda);
break;
case 3: consultar(agenda);
break;
case 4: listar(agenda); break;
}
}while (op!=5);
}
int menu()
{
int op;
do
{
cout<<"\n\t1. Introducir\n\t2. Borrar\n\t3.
Listar\n\t5. Salir\n\n";
cout<<"Introduce opcion : ";
cin>>op;
}while(op<0||op>5);
return op;
Consultar\n\t4.
}
void leer_datos(persona &per)
{
cout<<"\n\tNombre: "; cin>>per.nombre;
cout<<"\n\tTelefono: "; cin>>per.telefono;
cout<<"\n\tCiudad: "; cin>>per.ciudad;
}
void leer(lista &agenda)
{
persona per;
leer_datos(per);
insertar(agenda, ultimo(agenda), per);
}
void borrar(lista &agenda)
{
char nombre[50];
posicion p;
cout<<"\n\tNombre:"; cin>>nombre;
p=localizar(agenda, nombre);
if(p) suprimir(agenda, p);
else error("\nBorrar: no existe tal persona\n");
}
void escribir_datos(persona per)
{
cout<<"\n\tNombre:"<<per.nombre<<"\n\tTelefono:"
<<per.telefono <<"\n\tCiudad : "<<per.ciudad<<endl;
}
int consultar(lista agenda)
{
char nombre[50];
posicion p;
persona per;
cout<<"\n\tNombre: "; cin>>nombre;
p=localizar(agenda, nombre);
if(p)
{
per=recuperar(agenda, p);
escribir_datos(per);
}
else error("\nConsultar: no existe tal persona\n");
}
void listar(lista agenda)
{
if(esvacia(agenda)) error("\nListar: la agenda vacia\n");
else {
for(; agenda; agenda=agenda->sig)
escribir_datos(agenda->amigo);
}
}
Implementa una lista enlazada con nodo cabecera y utilizala para programar la
agenda de teléfonos.
Implementa una pila y utilizala para programar la agenda de teléfonos. Para ello,
los datos de las personas se van a introducir y borrar según dicha pila, y además
solo se va a poder consultar el tope de la pila.
Implementa una cola como una lista circular y utilizala para programar la agenda
de teléfonos. Los datos de las personas se deben introducir y borrar según la cola
y solo se va a poder consultar el primero de la cola.
Implementa una cola mediante dos punteros: uno al principio y otro al final de la
cola. Utiliza dicha cola para programar la agenda de teléfonos teniendo en
cuenta los mismos aspectos que en el apartado anterior.