//---------------------------------------------------------------------------

#pragma hdrstop
#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>
#include <string.h>
#include <cctype.h>
//---------------------------------------------------------------------------
typedef int datos;

typedef struct nodo

{
datos info;
nodo *sig;
}NODO;

double potencia(int a, int b)

{
// esta funcion tiene 3 casos base
if(b == 0 && a != 0)
return 1;

if(b == 1)
return a;
if(b == -1 )
return 1/(double)a;
//-----------------------
// llamadas recursivas
if(b < 0)
return 1/(double)a * potencia(a,b+1);
else
return a * potencia(a,b-1);
}
//----------------------------------------------------
//----------------------------------------------------
NODO *CreaNodo (datos valor)
{
NODO *p = NULL;
p = new NODO;
if (p != NULL)
{
 p->info = valor;
p->sig = NULL;
}
return p;
}
//----------------------------------------------------
// funcion para enlazar un nuevo nodo al inicio de una
// lista
//----------------------------------------------------
void Enlaza(NODO *p, NODO **pp)
{
if (p != NULL)
{
p->sig = *pp;
*pp = p;
}
}

//----------------------------------------------------
// Metodo que permite agregar un elemento en una lista
// en orden
//----------------------------------------------------
void EnlazarEnOrden(NODO **pp, datos valor)
{
NODO *actual;
NODO *nuevo;

nuevo = CreaNodo(valor);

if (nuevo != NULL)
{
if(*pp== NULL)
{
nuevo->sig = *pp;
*pp = nuevo;
return;
}
// verifica si hay que ingresar al principio
if((*pp)->info > valor)
{
nuevo->sig = *pp;
*pp= nuevo;
 }
else // sino buscar entre los nodos que se deben insertar
{

actual = *pp;

while(actual->sig != NULL && actual->sig->info < valor)

{
actual = actual->sig;
}
nuevo->sig = actual->sig;
actual->sig = nuevo;
}
}
}
//----------------------------------------------------
// Metodo que permite borrar el primer elemento de una
// lista
//----------------------------------------------------
void Borra (NODO **pp)
{
NODO *paux = *pp;
if (paux != NULL)
{
*pp = paux->sig;
delete paux;
}
}
//----------------------------------------------------
// dado un valor se borra el elemento de la lista
//----------------------------------------------------
void BorrarElemento(NODO **pp, datos valor)
{
NODO *actual;
NODO *anterior;
if(*pp == NULL)
return;
// se verifica si el primer elemento es que se debe eliminar
if((*pp)->info == valor)
{
actual = *pp;
*pp = (*pp)->sig;
 delete actual;
}
else
{
actual = (*pp)->sig;
anterior = *pp;
while(actual != NULL && actual->info != valor)
{
anterior = actual;
actual = actual->sig;
}

if(actual != NULL)
{
anterior->sig = actual->sig;
delete actual;
}
}
}
//----------------------------------------------------
// Metodo que permite borrar todos los nodos de una
// lista
//----------------------------------------------------
void BorrarLista(NODO **pp)
{
NODO *paux=NULL;
while (*pp != NULL)
{
paux= *pp;
*pp = (*pp)->sig;
delete paux;
}
}
//----------------------------------------------------
// esta función busca un elemento dado por el usuario
// y retorna el nodo donde se encuentra
// sino lo encuentra retorna NULL
//----------------------------------------------------
NODO *BuscaElemento (NODO *prim, datos valor_buscado)
{
int encontrado = 0;
while (prim != NULL && !encontrado)
 {
if (prim->info == valor_buscado)
encontrado = 1;
else
prim = prim->sig;
}

return prim;
}
//----------------------------------------------------
// metodo para la operacion de union de conjuntos
//----------------------------------------------------
void Union (NODO*L1, NODO *L2, NODO**L3)
{
while(L1 != NULL)
{
if(BuscaElemento(*L3,L1->info)== NULL)
EnlazarEnOrden(L3,L1->info);
L1 = L1->sig;
}

while(L2 != NULL)
{
if(BuscaElemento(*L3,L2->info)== NULL)
EnlazarEnOrden(L3,L2->info);
L2 = L2->sig;
}

//----------------------------------------------------
// Metodo para diferencia de dos conjuntos
void diferencia(NODO *L1,NODO *L2,NODO **L3)
{
while (L1!=NULL)
{
if (BuscaElemento(L2,L1->info)==NULL)
EnlazarEnOrden(L3,L1->info);
L1=L1->sig;
}
}
//----------------------------------------------------
 void Interseccion (NODO*L1, NODO *L2, NODO**L3)
{
if (L1 && L2)
{
while ( L1!=NULL)
{
if (BuscaElemento(L2,L1->info)!=NULL)
EnlazarEnOrden(L3,L1->info);
L1=L1->sig;
}
}
else
*L3= NULL;
}
//----------------------------------------------------
// método que permite mostrar todos los elementos de una lista
// en una tabla
//----------------------------------------------------
void imprimirlista(NODO *p)
{
if(p)
{
cout<<"______________________________________"<<endl;
cout<<setw(6)<<"Nodo"<<setw(6)<<'\t' <<setw(6)<<"Info\t"<<
setw(10)<<"Apunta a"<<endl;
cout<<"______________________________________"<<endl;
while(p != NULL)
{
cout<< setw(10) << p <<"\t";
cout<< setw(6) << p->info <<"\t";
cout<< setw(10) << p->sig <<"\t"<<endl;
p = p->sig;
}
cout<<"______________________________________"<<endl;
}
else
cout << "La lista esta vacia"<<endl;
}
//----------------------------------------------------
// funcion que verifica que todos los elementos de una lista
// estan ordenados
//----------------------------------------------------
bool verificar(NODO *p)
{
if(p== NULL)
return true;

while (p->sig != NULL)

{
if(p->info < p->sig->info)
p = p->sig;
else
return false;
}
return true;
}
//----------------------------------------------------
//----------------------------------------------------
int contar_nodo(NODO *p)
{
int cont=0;

while (p != NULL)
{
cont++;
p = p->sig;
}
return cont;
}
//----------------------------------------------------
//----------------------------------------------------
void buscarmenor(NODO *p)
{
if(p == NULL)
{
cout<< "Lista vacia"<<endl;
return;
}

int menor = INT_MAX;

while (p!=NULL)
{
if (p->info < menor)
menor = p->info;
 p=p->sig;
}
cout<<"El menor es: "<<menor;
}
//----------------------------------------------------
/* Programa Princial */
//----------------------------------------------------
#pragma argsused

void main()
{
//declaracion de variables
char opcion= 's';
int cant =0,cant2=0;
NODO * Lista=NULL;
NODO *A,*B,*C;
A=B=C= NULL;
datos numero =1;
srand(9000);
cout<<"potencia 3, 3 "<< potencia(3,3)<<endl;
cout<<"potencia 3, -3 "<< potencia(3,-3)<<endl;
cout<<"potencia 3, 0 "<< potencia(3,0)<<endl;
cout<<"potencia 3, -1 "<< potencia(3,-1)<<endl;

cout<<endl<<"Programa de Prueba"<<endl;
cout<<"Manejo de Listas Simplemente Enlazadas"<<endl<<endl;

buscarmenor(Lista);
cout<< "Ingrese la cantidad de elementos a generar de forma aleatoria"<< endl;
cout<< "un número entre 1 y 20"<< endl;

while (cant2 < 1 || cant2 > 20)

{
cout<<"cantidad: ";
cin>> cant2;
}
cant = cant2;
// este ciclo permite generar 20 números aleatorios
// y se insertar en orden en la lista enlazada
while (cant > 0)
{
 numero = rand();
cout<<"Numero: "<< numero<<endl;
if(numero != 0)
{
// primero se verifica que no este repetido el número
// en la lista
if(BuscaElemento(A,numero)== NULL)
{
EnlazarEnOrden(&A,numero);
cant--;
}
else
{
cout<<"El elemento esta repetido"<<endl;
}
}

} // fin de insertar elementos en la lista

cant = cant2;
while (cant > 0)
{
numero = rand();
cout<<"Numero: "<< numero<<endl;
if(numero != 0)
{
// primero se verifica que no este repetido el número
// en la lista
if(BuscaElemento(B,numero)== NULL)
{
EnlazarEnOrden(&B,numero);
cant--;
}
else
{
cout<<"El elemento esta repetido"<<endl;
}
}

} // fin de insertar elementos en la lista

cout<<"Elementos de la Lista A"<<endl;
EnlazarEnOrden(&A,B->info);
 imprimirlista(A);
cout<<"Elementos de la Lista B"<<endl;
imprimirlista(B);
cout<<"Operaciones de Conjuntos"<<endl;
Union(A,B,&C);
cout<<"Elementos de la unión de A con B"<<endl;
imprimirlista(C);
BorrarLista(&C);
Interseccion(A,B,&C);
cout<<"Elementos de la interseccion A con B"<<endl;
imprimirlista(C);
BorrarLista(&C);
Interseccion(A,A,&C);
cout<<"Elementos de la interseccion A con A"<<endl;
imprimirlista(C);

BorrarLista(&C);
diferencia(B,A,&C);
cout<<"Elementos de la Diferencia"<<endl;
imprimirlista(C);

cant = cant2;
// solicita un numero entre 1 y 20
while (cant < 1 || cant > 20)
{
cout<<"cantidad: ";
cin>> cant;
}
// este ciclo permite generar 20 números aleatorios
// y se insertar en orden en la lista enlazada
while (cant > 0)
{
numero = rand();
// cout<<"Numero: "<< numero<<endl;
if(numero != 0)
{
// primero se verifica que no este repetido el número
// en la lista
if(BuscaElemento(Lista,numero)== NULL)
 {
EnlazarEnOrden(&Lista,numero);
cant--;
}
else
{
cout<<"El elemento esta repetido"<<endl;
}
}

} // fin de insertar elementos en la lista

imprimirlista(Lista);

cout<<"Número de elementos de la lista: "<< contar_nodo(Lista)<<endl;

if (verificar(Lista))
cout<< "La lista esta ordenada"<<endl;
else
cout<<"La lista no esta ordenada"<<endl;

cout <<endl;
buscarmenor(Lista);
cout <<endl;

while(toupper(opcion) != 'N' && Lista != NULL)

{
cout<<endl<<"Ingrese el número a borrar: ";
cin>> numero;

BorrarElemento(&Lista,numero);
imprimirlista(Lista);

cout <<endl;
buscarmenor(Lista);
cout <<endl;

if(Lista)// si la lista no esta vacia

{
cout <<"Desea borrar otro elemento (s/n)";
cin>> opcion;
}
 }

BorrarLista(&Lista);
BorrarLista(&A);
BorrarLista(&B);
BorrarLista(&C);
cout<< endl<< "fin del programa";
cin>>numero;
}
//---------------------------------------------------------------------------