Talleres
------------------------------------------------------------------------------------
<1> El siguiente programa utiliza dos archivos para el manejo de artículos y movimiento de artículos en un kárdex. Modificar el programa para permitir la consulta con acceso directo, generar el listado de movimientos y actualización (entradas\salidas) del inventario.
#include "iostream.h"
#include "dos.h"
#include "conio.h"
#include "stdio.h"
#define lp clrscr();
#define g gotoxy
struct articulo
{
int codigo;
char nombre[60];
}artic;
struct movimientos
{
int codigo,tipo,cantid;
long fecha;
}movim;
int t=sizeof(articulo),codiaux,opc;
int t1=sizeof(movim);
char bandera;
FILE *art,*mov; // puntero al archivo
void titulos(){
g(15,8); cout <<"CODIGO ARTICULO :";
g(15,9); cout <<"NOMBRE :";
}
void titulos1(){
g(15,8); cout <<"CODIGO ARTICULO :";
g(15,9); cout <<"CANTIDAD :";
g(15,10); cout <<"TIPO MOVIMIENTO (1=Entrada, 2=Salida):";
g(15,11); cout <<"FECHA (DDMMAA) :";
}
void buscar(int codg) { //funcion busqueda con paso de parametros
bandera = 'f'; //falso
fseek(art,0l,0); //ubicandose en el comienzo del archivo
//rewind(art); " "
while((!feof(art))&&(bandera=='f')) {
fread(&artic,t,1,art); //fread lee el archivo de t bytes
if(artic.codigo==codg)
{
bandera='t'; //verdadero
}
}
}
void adicionar_art(){
// fopen abre un archivo. En este caso "Kardex.dat" y
// asigna su direccion al puntero art
art=fopen("Kardex.dat","rb+");
if(art==NULL) {
g(24,22);cout<< " <<ERROR CREANDO ARCHIVO>> ";
}
else {
lp
g(15,6);
cout <<" I N G R E S O D E A R T I C U L O";
titulos(); //Llama la funcion titulos()
g(35,8); cin>>codiaux;
buscar(codiaux); //Llama la funcion BUSCAR con el codigo
if (bandera =='t') {
g(20,20); cout <<"ERROR!!!, CODIGO DE ARTICULO YA EXISTE!";
getche();
}
else {
artic.codigo = codiaux;
g(35,9);
gets(artic.nombre);
fwrite(&artic,t,1,art); //escribe un artículo al final del archivo
}
}
fclose(art); //cierra el archivo
}
void consultar_art(){
lp
bandera='f';
g(15,5); cout <<"CONSULTA POR CODIGO";
g(10,10); cout <<"CODIGO DEL ARTICULO A CONSULTAR -> ";
cin >> codiaux;
art=fopen("Kardex.dat","r");
if(art==NULL) {
g(25,20); cout <<"<<ERROR ABRIENDO ARCHIVO>>";
}
else {
lp
rewind(art);
while(!feof(art)){
fread(&artic,t,1,art);
if (artic.codigo == codiaux) {
lp
bandera='t';
titulos(); g(35,8);
cout<<artic.codigo; g(35,9);
cout<<artic.nombre;
getche();
break;
}
}
if (bandera=='f'){
g(20,20); cout <<"CODIGO DE ARTICULO NO EXISTE!";
sleep(5);}
}
fclose(art);
}
void listar_art(){
art=fopen("Kardex.dat","r");
if(art==NULL){
g(25,20); cout <<"<<ERROR ABRIENDO ARCHIVO...";
getche();
}
else {
rewind(art);
while(!feof(art)){
fread(&artic,t,1,art);
lp
titulos(); g(35,8);
cout<<artic.codigo; g(35,9);
cout<<artic.nombre;
getche();
}
}fclose(art);
}
void movim_art(){
mov=fopen("Mvkardex.dat","rb+");
if(mov==NULL){
g(24,22);cout<< " <<ERROR CREANDO ARCHIVO>> ";
}
else{
lp
g(15,6);
cout <<" I N G R E S O D E M O V I M I E N T O";
titulos1();
g(35,8); cin>>codiaux;
art=fopen("Kardex.dat","r");
buscar(codiaux);
if (bandera =='f'){
g(20,20); cout <<"ERROR!!!, CODIGO DE ARTICULO NO EXISTE!";
getche();
}
else{
movim.codigo = codiaux;
g(35,9); cin >> movim.cantid;
do{
g(53,10);cin >> movim.tipo;
}while(movim.tipo<1 || movim.tipo>2);
g(35,11);cin >> movim.fecha;
fwrite(&movim,t1,1,mov);
}
}
fclose(mov);
fclose(art);
}
void menu(){
do{
lp
g(16,6);cout <<" M E N U P R I N C I P A L ";
g(16,9);cout <<" <DATOS DE ARTICULOS> ";
g(16,11);cout <<" 1. ARTICULOS ";
g(16,12);cout <<" 2. CONSULTAR ";
g(16,13);cout <<" 3. LISTAR ARTICULOS ";
g(16,14);cout <<" 4. MOVIMIENTOS ";
g(16,15);cout <<" 5. SALIR ";
g(16,18);cout <<" Por favor, digite su OPCION... [ ]";
do{
g(49,18); cin>>opc;
}while((opc<1)&&(opc>5));
switch(opc){
case 1: adicionar_art(); break;
case 2: consultar_art(); break;
case 3: listar_art(); break;
case 4: movim_art(); break;
}
}while(opc!=5);
}
void main(){
lp
menu();
}
<2> Escribir un
programa que permita crear los archivos relacionados
"Constructores.dat" y "PilotosF1.dat". Los archivos deben
registrar
mínimo la siguiente información:
- Código y nombre del constructor (equipo)
- Total campeonatos ganados por el constructor
- Código, nombre y nacionalidad del piloto
- Número de poole position obtenidas
- Número de carreras ganadas
- Total campeonatos de Fórmula 1 ganados.
-------------------
Menú principal
1. Constructores
2. Pilotos F1
3. Informes
4. Salir
-------------------
El programa debe visualizar los siguientes informes:
> Nombre del constructor con más títulos obtenidos
> Registro del piloto con más carreras ganadas
> Registro del piloto rey de la F1
> Listado de pilotos ganadores de poole position.
<3>
Escribir un programa que permita crear los archivos relacionados
"Profesores.dat", "Programas.dat" y "Facultades.dat".
Las estructuras son las siguientes:
struct Profesor{
struct Programa{
struct Facultad{
long cedula;
int codpro;
int codfac;
char nombre[25];
char nompro[25];
char nomfac[25];
int categ,codpro;
int codfac;
}
float sueldo;
}
}
-------------------
Menú principal
1. Facultades
2. Programas
3. Profesores
4. Informes
5. Salir
-------------------
El programa debe visualizar los siguientes informes:
> Listado de los profesores con categoría 4
> Nombre del Programa que más profesores tiene (cuántos?)
> Registro del profesor con el sueldo má$ alto.
---------------------------------------------------------------------------------
<4> Uso de argumentos de línea de comandos (main con parámetros)
Talleres
a) Escriba un programa que tome dos argumentos numéricos de la línea de comandos y visualice su producto.
b) Escriba un programa con argumentos de línea de comandos que copie un archivo en otro archivo, caracter por caracter. (una versión del comando COPY)
------------------------------------------------------------------------------------
<5> Árboles
// Programa ejemplo para crear un arbol binario
#include "iostream.h"
#include "conio.h"
#define cls clrscr()
struct ArbolBin
{
int info;
ArbolBin *izq;
ArbolBin *der;
}*raiz=0;
ArbolBin *buscar(ArbolBin *raiz,int nodo){
if (!raiz)
return raiz; // arbol vacio
while (raiz->info != nodo){
if (nodo < raiz->info)
raiz = raiz->izq;
else
raiz = raiz->der;
if (raiz == NULL)
break;
}
return raiz;
}
// La primera vez que se ejecute la función siguiente será para
almacenar la raiz, con lo que los valores iniciales de raiz y de
aux son NULL. En este caso se asigna memoria dinámica con new,
se almacenan el dato y los punteros de la izquierda y de la derecha a NULL,
y se retorna el valor del puntero de la primera entrada (puntero aux).
La segunda y posteriores entradas de datos harán que la función
creaArbol( ) se ejecute y siendo (!aux) falso en la primera
recursión, se compara el dato introducido con el dato almacenado en la
raiz y se llama a la función creaArbol( ), pero pasando como
argumentos los punteros de aux y de aux->izq o aux->der
según sea el dato menor o mayor que el campo clave (info).
ArbolBin *creaArbol(ArbolBin *raiz, ArbolBin *aux, int dato){
if (!aux){
aux = new ArbolBin;
aux->izq = NULL;
aux->der = NULL;
aux->info = dato;
if (!raiz)
return aux; // primer nodo = raiz
if (dato < raiz->info)
raiz->izq = aux;
else
raiz->der = aux;
return (aux);
}
if (dato < aux->info)
return creaArbol(aux,aux->izq,dato);
else if (dato > aux->info)
return creaArbol(aux,aux->der,dato);
}
void lista_preorden(ArbolBin *aux){
if (!aux){
cout << "El Arbol vacio!";return;}
cout << aux->info<<" ";
lista_preorden(aux->izq);
lista_preorden(aux->der);
}
void entra_nodo(){
int dato;
do{
cls;
cout << "Por favor, ingrese un valor numerico, " << endl;
cout << "o digite 0 para terminar... -> ";
cin >> dato;
if (dato)
if (!raiz)
raiz = creaArbol(raiz,raiz,dato);
else
creaArbol(raiz,raiz,dato);
}while(dato);
} // El ciclo do-while recoge los datos, llamando la primera
vez a la función creaArbol( ) que retornará un puntero a raiz,
el cual permanecerá constante durante toda la ejecución del programa.
void main ()
{
int siga=1;
while(siga){
cls;
cout << " MENU DEL ARBOL BINARIO"<<endl<<endl;
cout << " 1. Adicionar Nodo"<<endl;
cout << " 2. Listar Arbol"<<endl;
cout << " 3. Salir"<<endl;
switch(getch())
{
case '1': entra_nodo();break;
case '2': cout<<endl;lista_preorden(raiz);
getch();break;
case '3': siga=0;
}
}
}
// TALLER DE PROGRAMACION:
// Combinar la funcion de busqueda con la insercion de nodos
// Implementar la funcion borrar en un arbol binario
// Listar el arbol en inorden y postorden.
-----------------------------------------------------------------------------------
<6> Recorrido de Grafos
Una de las operaciones básicas en el manejo de grafos es su recorrido. Existen diferentes algoritmos que desarrollan metodologías para hacerlo, estos dependen de la estructura de datos en la que esté almacenado el grafo. Hay métodos de tipo general para el recorrido de grafos, como el método de profundidad y el método de expansión. En ambos casos, debido a que es posible visitar un nodo más de una vez, es necesario marcar el nodo visitado como tal.
TALLER No. 1
| Nodo | Adyacentes |
|
A |
F C B |
| B | G C |
| C | F |
| D | C |
| E | D C J |
| F | D |
| G | C E |
| J | D K |
| K | E G |
- Implementar en lenguaje C/C++ los algoritmos para recorrido del Grafo de la representación anterior:
Búsqueda por expansión (o por anchura):
1. Iniciar todos los nodos a Estado = 1
2. Acolar el nodo de partida y cambiar su estado a Estado = 2
3. Repetir pasos 4 y 5 hasta que cola = vacía
4. Desacolar nodo, procesar nodo y cambiar a Estado = 3
5. Acolar los vecinos del nodo cuyo Estado = 1 y cambiar a Estado = 2
6. Salir
A F C B D G E J K
Búsqueda por profundidad
1.Iniciar todos los nodos a Estado = 1
2. Apilar el nodo de partida y cambiar su estado a Estado = 2
3. Repetir pasos 4 y 5 hasta que pila = vacía
4. Desapilar nodo, procesar nodo y cambiar a Estado = 3
5. Apilar los vecinos del nodo cuyo Estado = 1 y cambiar a Estado = 2
6. Salir
A B G E J K D C F
***************************************************************
// Software básico para manejo de árboles AVL
#include "iostream.h"
#include "alloc.h"
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#define TRUE 1
#define FALSE 0
#define MARCA -1
#define IZQ 1
#define BAL 0
#define DER -1
#define MAX 100
typedef int TipoAVL;
typedef struct NodoAVL
{ TipoAVL info;
struct NodoAVL *izq, *der;
int balan;
} TAVL,*AVL;
typedef AVL TipoC;
typedef struct
{ TipoC info[ MAX ];
int primero,
ultimo;
} TCola, *Cola;
typedef TipoAVL TipoL;
typedef struct ListaNodo
{ TipoL info;
struct ListaNodo *ant, *sig;
} *pListaNodo;
typedef struct
{ pListaNodo primero, ultimo, ventana;
int longitud;
} TLista, *Lista;
typedef pListaNodo Ventana;
Cola inicCola( void )
{ Cola col;
col = ( Cola )malloc( sizeof( TCola ) );
col->primero = col->ultimo = -1;
return col;
}
void adicCola( Cola col, TipoC elem )
{ if ( col->primero == -1 )
{ col->info[ 0 ] = elem;
col->primero = col->ultimo = 0;
}
else
{ col->ultimo = ( col->ultimo + 1 ) % MAX;
col->info[ col->ultimo ] = elem;
}
}
void elimCola( Cola col )
{ if ( col->primero == col->ultimo )
col->primero = col->ultimo = -1;
else
col->primero = ( col->primero + 1 ) % MAX;
}
TipoC infoCola( Cola col )
{ return col->info[ col->primero ];
}
int vaciaCola( Cola col )
{ return col->primero == -1 && col->ultimo == -1;
}
void destruirCola( Cola col )
{ free( col );
}
Lista inicLista( void )
{ Lista resp;
resp = ( Lista )malloc( sizeof( TLista ) );
resp->primero = resp->ultimo =resp->ventana= NULL;
resp->longitud = 0;
return resp;
}
void anxLista( Lista lst, TipoL elem )
{ pListaNodo nuevo = ( pListaNodo )malloc( sizeof( struct ListaNodo ) );
nuevo->info = elem;
nuevo->ant = nuevo->sig = NULL;
if ( lst->longitud == 0 )
lst->primero = lst->ultimo = nuevo;
else if ( lst->ventana == lst->ultimo )
{ lst->ventana->sig = lst->ultimo = nuevo;
nuevo->ant = lst->ventana;
}
else
{ nuevo->ant = lst->ventana;
nuevo->sig = lst->ventana->sig;
lst->ventana->sig->ant = nuevo;
lst->ventana->sig = nuevo;
}
lst->ventana = nuevo;
lst->longitud++;
}
void insLista( Lista lst, TipoL elem )
{ pListaNodo nuevo = ( pListaNodo )malloc( sizeof( struct ListaNodo ) );
nuevo->info = elem;
nuevo->ant = nuevo->sig = NULL;
if ( lst->longitud == 0 )
lst->primero = lst->ultimo = nuevo;
else if ( lst->ventana == lst->primero )
{ lst->primero = lst->ventana->ant = nuevo;
nuevo->sig = lst->ventana;
}
else
{ nuevo->sig = lst->ventana;
nuevo->ant = lst->ventana->ant;
lst->ventana->ant->sig = nuevo;
lst->ventana->ant = nuevo;
}
lst->ventana = nuevo;
lst->longitud++;
}
void elimLista( Lista lst )
{ pListaNodo aux;
if ( lst->ventana == lst->primero )
{ if ( lst->ultimo == lst->primero )
lst->ultimo = NULL;
lst->primero = lst->primero->sig;
free( lst->ventana );
lst->ventana = lst->primero;
}
else
{ if ( lst->ultimo == lst->ventana )
lst->ultimo = lst->ultimo->ant;
lst->ventana->ant->sig = lst->ventana->sig;
if ( lst->ventana->sig != NULL )
lst->ventana->sig->ant = lst->ventana->ant;
aux = lst->ventana;
lst->ventana = lst->ventana->sig;
free( aux );
}
lst->longitud--;
}
void sigLista( Lista lst )
{ lst->ventana = lst->ventana->sig;}
void primLista( Lista lst )
{ lst->ventana = lst->primero;}
void posLista( Lista lst, int pos )
{ int i;
for ( lst->ventana = lst->primero, i = 1; i < pos; i++ )
lst->ventana = lst->ventana->sig;
}
TipoL infoLista( Lista lst )
{ return lst->ventana->info;}
int longLista( Lista lst )
{ return lst->longitud;}
int finLista( Lista lst )
{ return lst->ventana == NULL;}
void destruirLista( Lista lst )
{ pListaNodo p, q;
for( p = lst->primero; p != NULL; )
{ q = p;
p = p->sig;
free( q );
}
free( lst );
}
AVL inicAVL( void )
{ return NULL;}
AVL roteIzq( AVL a )
{ AVL temp=a->der;
a->der=temp->izq;
temp->izq=a;
return temp;
}
static AVL roteDer( AVL a )
{ AVL temp=a->izq;
a->izq=temp->der;
temp->der=a;
return temp;
}
AVL roteDerIzq( AVL a )
{ a->der=roteDer( a->der );
return roteIzq( a );
}
static AVL roteIzqDer( AVL a )
{ a->izq=roteIzq( a->izq );
return roteDer( a );
}
AVL balanceaDer( AVL a )
{ if( a->der->balan==DER )
{ // Caso 2
a->balan=a->der->balan=BAL;
a=roteIzq( a );
}
else
{ // Caso 4
switch( a->der->izq->balan )
{ case IZQ: a->balan=BAL;
a->der->balan=DER;
break;
case BAL: a->balan=a->der->balan=BAL;
break;
case DER: a->balan=IZQ;
a->der->balan=BAL;
break;
}
a->der->izq->balan=BAL;
a=roteDerIzq( a );
}
return a;
}
AVL balanceaIzq( AVL a )
{ if( a->izq->balan==IZQ )
{ // Caso 3
a->balan=a->izq->balan=BAL;
a=roteDer( a );
}
else
{ // Caso 5
switch( a->izq->der->balan )
{ case IZQ: a->balan=DER;
a->izq->balan=BAL;
break;
case BAL: a->balan=a->izq->balan=BAL;
break;
case DER: a->balan=BAL;
a->izq->balan=IZQ;
break;
}
a->izq->der->balan=BAL;
a=roteIzqDer( a );
}
return a;
}
AVL insertar( AVL a, AVL p, int *masAlto )
{ if( a==NULL )
{ *masAlto=TRUE;
a=p;
}
else if( a->info>p->info )
{ a->izq=insertar( a->izq,p,masAlto );
if( *masAlto )
switch( a->balan )
{ case IZQ: *masAlto=FALSE;
a=balanceaIzq(a);
break;
case BAL: a->balan=IZQ;
break;
case DER: *masAlto=FALSE;
a->balan=BAL;
break;
}
}
else
{ a->der=insertar(a->der,p,masAlto);
if( *masAlto )
switch( a->balan )
{ case IZQ: *masAlto=FALSE;
a->balan=BAL;
break;
case BAL: a->balan=DER;
break;
case DER: *masAlto=FALSE;
a=balanceaDer( a );
}
}
return a;
}
AVL insAVL( AVL a, TipoAVL elem )
{ AVL p=( AVL )malloc( sizeof( TAVL ) );
int masAlto;
p->izq=p->der = NULL;
p->info = elem;
p->balan = BAL;
return insertar( a, p, &masAlto );
}
AVL balanIzq( AVL a, int *menosAlto )
{ switch( a->balan )
{ case IZQ: if( a->izq->balan!=DER )
{ a=roteDer( a );
if( a->balan==BAL )
{ a->balan=DER;
a->der->balan=IZQ;
*menosAlto=FALSE;
}
else
a->balan=a->der->balan=BAL;
}
else
{ a=roteIzqDer( a );
a->der->balan=( a->balan==IZQ )?DER:BAL;
a->izq->balan=( a->balan==DER )?IZQ:BAL;
a->balan=BAL;
}
break;
case BAL: a->balan=IZQ;
*menosAlto=FALSE;
break;
case DER: a->balan=BAL;
break;
}
return a;
}
AVL balanDer( AVL a, int *menosAlto )
{ switch( a->balan )
{ case IZQ: a->balan=BAL;
break;
case BAL: a->balan=DER;
*menosAlto=FALSE;
break;
case DER: if( a->der->balan!=IZQ )
{ a=roteIzq( a );
if( a->balan==BAL )
{ a->balan=IZQ;
a->izq->balan=DER;
*menosAlto=FALSE;
}
else
a->balan=a->izq->balan=BAL;
}
else
{ a=roteDerIzq( a );
a->izq->balan=( a->balan==DER )?IZQ:BAL;
a->der->balan=( a->balan==IZQ )?DER:BAL;
a->balan=BAL;
}
break;
}
return a;
}
TipoAVL mayorElemento( AVL a )
{ if( a->der==NULL )
return a->info;
else
return mayorElemento( a->der );
}
AVL eliminar( AVL a, TipoAVL elem, int *menosAlto )
{ AVL p;
int mayor;
if( a->info == elem )
{ if( a->izq == NULL && a->der == NULL )
{ free( a );
*menosAlto = TRUE;
return NULL;
}
else if( a->izq == NULL )
{ p = a->der;
free( a );
*menosAlto = TRUE;
return p;
}
else
{ mayor = mayorElemento( a->izq );
a->info = mayor;
a->izq = eliminar( a->izq, mayor, menosAlto );
if( *menosAlto )
a = balanDer( a, menosAlto );
}
}
else if( a->info > elem )
{ a->izq = eliminar( a->izq, elem, menosAlto );
if( *menosAlto )
a = balanDer( a, menosAlto );
}
else
{ a->der = eliminar( a->der, elem, menosAlto );
if( *menosAlto )
a=balanIzq( a, menosAlto );
}
return a;
}
AVL elimAVL( AVL a, TipoAVL elem )
{ int menosAlto;
return eliminar( a, elem, &menosAlto );
}
int estaAVL( AVL a, TipoAVL elem )
{ if( a == NULL )
return FALSE;
else if( a->info == elem )
return TRUE;
else if( a->info > elem )
return estaAVL( a->izq, elem );
else
return estaAVL( a->der, elem );
}
void impBlancos( int n )
{ for( n = ( n < 2 ) ? 2 : n; n>0; n-- )
cout<< " " ;
}
void niveles( AVL a )
{ Lista lst = inicLista( );
Cola col;
int numElem=1, i=0, nivelVacio=TRUE;
if ( a!=NULL )
{ adicCola( col=inicCola( ),a );
while( !vaciaCola( col ) )
{ a=infoCola( col );
elimCola( col );
if ( a!=NULL )
{ nivelVacio=FALSE;
anxLista( lst,a->info );
adicCola( col,a->izq );
adicCola( col,a->der );
}
else
{ anxLista( lst, MARCA );
adicCola( col, NULL );
adicCola( col, NULL );
}
if( ++i==numElem )
{ if( nivelVacio )
{ destruirCola( col );
destruirLista( lst );
return;
}
for(primLista(lst);!finLista(lst);sigLista(lst))
{ impBlancos((64-(numElem*2))/(numElem+1));
if( infoLista( lst ) == MARCA ) cout<<"* ";
else cout<<infoLista( lst ) ;
}
cout<<"\n";
destruirLista( lst );
lst=inicLista( );
nivelVacio=TRUE;
numElem*=2;
i=0;
}
}
}
}
void inorden( AVL a )
{ if( a!=NULL )
{ inorden( a->izq );
cout<<a->info ;
inorden( a->der );
}
}
int altoAVL( AVL a )
{ if( a==NULL )
return 0;
else if( a->izq==NULL && a->der==NULL )
return 1;
else
{ int alt1 = altoAVL( a->izq );
int alt2 = altoAVL( a->der );
return ( ( alt1 > alt2 ) ? alt1 : alt2 ) + 1;
}
}
int esAVL( AVL a )
{ int alt1,alt2,dif;
if( a==NULL || ( a->izq==NULL && a->der==NULL ) )
return 1;
else
{ alt1=altoAVL( a->izq );
alt2=altoAVL( a->der );
dif=alt1-alt2;
if( dif!=a->balan )
cout<< "Factor de balance errado\n" ;
if( dif<-1 || dif>1 )
cout<< "Arbol mal balanceado\n";
return esAVL( a->izq ) && esAVL( a->der );
}
}
void main()
{
AVL a1;
Lista lst;
int num, i, longi;
int elem = -1;
char resp;
a1=inicAVL( );
textcolor(WHITE);
textbackground(BLUE);
clrscr();
while( elem!=0 )
{
gotoxy(30,6);cout << "MENU PRINCIPAL";
gotoxy(22,8);cout<<"1. Insertar\n" ;
gotoxy(22,9);cout<< "2. Eliminar\n" ;
gotoxy(22,10);cout<< "3. Buscar\n" ;
gotoxy(22,11);cout<< "4. Probar operaciones automaticamente\n" ;
gotoxy(22,12);cout<< "5. Salir\n" ;
gotoxy(22,13);cout<<"Opcion : [ ]";
gotoxy(32,13);cin>>elem;
clrscr();
switch(elem)
{
do{
case 1: // Insertar
cout<<"Elemento: " ;
cin>>elem ;
a1=insAVL( a1,elem );
cout<<"desea ingresar mas elementos s/n"<<endl;
cin>>resp;
}while (resp=='s'||resp=='S');
break;
getch();
case 2: // Eliminar
cout<<"Elemento: " ;
cin>>elem ;
a1=elimAVL( a1,elem );
break;
case 3: // Buscar
cout<<"Elemento: " ;
cin>>elem ;
if( estaAVL( a1,elem ) )
cout<< "Elemento " <<elem<<" SI esta presente\n" ;
else
cout<<"Elemento "<<elem<<" NO esta presente\n";
break;
case 4: // Probar automaticamente las operaciones
cout<< "> Numero de elementos: " ;
cin>>num ;
// Inserta num valores aleatorios en el rango 1..num*5
a1=inicAVL( );
lst = inicLista( );
cout<<"Insertando" ;
for( i = 1; i <= num; i++ )
{ elem = random( num*5 )+1;
if( !estaAVL( a1,elem ) )
{ insLista( lst,elem );
a1=insAVL( a1,elem );
}
cout<< "." ;
if( !estaAVL( a1,elem ) )
cout<< "ERROR en operacion de insercion\n" ;
if( !esAVL( a1 ) )
cout<<"ERROR estructural en arbol 2-3\n" ;
}
// Imprime el orden del arbol
cout<<"\n" ;
inorden( a1 );
cout<< "\n" ;
// Imprime el arbol por niveles
niveles( a1 );
// Elimina aleatoriamente cada elemento insertado
cout<< "Eliminando" ;
longi=longLista( lst );
for( ; longi > 0; )
{ posLista( lst, i = random( longi )+1 );
elem = infoLista( lst );
a1=elimAVL( a1,elem );
elimLista( lst );
cout<< "." ;
if( estaAVL( a1,elem ) )
cout<<"ERROR en operacion de supresion\n" ;
if( !esAVL( a1 ) )
cout<< "ERROR estructural en arbol 2-3\n" ;
longi=longLista( lst );
}
break;
case 5:exit(0);
}
// Imprime el inorden del arbol
inorden( a1 );
cout<< "\n" ;
// Imprime el arbol por niveles
niveles( a1 );
cout<<"\n" ;
getch();
clrscr();
// Verifica que haya quedado bien construido el arbol
if( !esAVL( a1 ) )
return;
}
}
