#include <iostream>

#include <stdlib.h>

#include <conio.h>

#include <stdlib.h>

#define clrscr() system("cls");

#define max 100

using namespace std;

int opc=0, opcl=0, valor=0, pos=0, cont=0, i=0;

int arr[10];

int t[10];

/*funciones de menu */

void menupila();

void menucola();

void menuordenamiento();

void menubusqueda();

void menurecurividad();

void menulistas();

void menulistassimples();

void menulistascirculares();
void menulistasdobles();

/* funcion pila*/

void agregar();

void eliminar();

void mostrar();

/* funcion cola*/

void agregarcola();

void eliminarcola();

void mostrarcola();

/* funcion ordenamiento insercion*/

void ordenainsercion();

/* funcion ordenamiento burbuja*/

void ordenamiento_burbuja();

/* funcion busqueda secuencial*/

void busquesecuencial() ;

/* funciones busqueda binaria */

void ingresarArreglo(float A[max],int n);

void reportarVector(float V[max],int n);

void ordenarSeleccion(float V[max],int n);

int busquedaBinaria(float V[max],int n ,int dato);

int busquebinaria();

/* funciones recursivas */

/* funciones suma de elementos de un vector*/

int recursumavector();

int sumaVector(int t[], int n);

/* funcion MCM */

int comunmultiplo();

int mcm(int div, int n1, int n2);

/* elemento mayor de une vector*/

int verElementoMayor(int n,int pos);

void elementomayor();

/* funciones listas */

/* listas sencillas */

void adicionar_inicio_sencilla();

void adicionar_final_sencilla();

void eliminar_inicio_sencilla();

void eliminar_final_sencilla();

void mostrar_lista_sencilla();

void adicionar_valor_sencilla();

void adicionar_posicion_sencilla();
void eliminar_valor_sencilla();

void eliminar_posicion_sencilla();

/* listas circulares */

void adicionar_inicio_circular();

void adicionar_final_circular();

void eliminar_inicio_circular();

void eliminar_final_circular();

void mostrar_lista_circular();

void adicionar_valor_circular();

void adicionar_posicion_circular();

void eliminar_valor_circular();

void eliminar_posicion_circular();

/* listas dobles */

void adicionar_inicio_doble();

void adicionar_final_doble();

void eliminar_inicio_doble();

void eliminar_final_doble();

void mostrar_lista_doble();

void adicionar_valor_doble();
 void adicionar_posicion_doble();

void eliminar_valor_doble();

void eliminar_posicion_doble();

/* Definicion de estructuras */

///////////////DEFINIENDO ESTRUCTURA PARA LISTAS SIMPLES///////////////////////////////////////

struct nodo

int info;

nodo *sig;

} *cab=NULL,*ult=NULL,*p,*q,*aux;

///////////////DEFINIENDO ESTRUCTURA PARA LISTAS CIRCULARES///////////////////////////////////////

struct nodoc

int info;

nodoc *sig;

}*cabc=NULL,*ultc=NULL,*pc,*qc,*auxc;

///////////////DEFINIENDO ESTRUCTURA PARA LISTAS DOBLES///////////////////////////////////////

struct nodod
{

int info;

nodod *sig;

nodod *ant;

}*cabd=NULL,*ultd=NULL,*pd,*qd,*auxd,*r;

///////////////DEFINIENDO ESTRUCTURA PARA PILA//////////////////////////////////////////////////

struct nodop

int info;

nodop *ant;

}*Aux,*Cab=NULL;

///////////////DEFINIENDO ESTRUCTURA PARA COLA///////////////////////////////////////

struct cola

int dato;

cola *siguiente;

}*Auxiliar,*Ultimo,*Cabecera=NULL;

/*----------------------------------------------MENU PRINCIPAL------------------------------------------*/
void menu()

while (opc != 7)

clrscr();

cout<<"\t Menu Principal\n";

cout<<"1. Pila\n";

cout<<"2. Cola\n";

cout<<"3. Ordenamiento\n";

cout<<"4. Busqueda\n";

cout<<"5. Recursividad\n";

cout<<"6. Listas\n";

cout<<"7. Salir\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

{///////////////LLAMADO A LAS FUNCIONES DEL MENU PRINCIPAL /////////////////////////////////////////////////

case 1: menupila(); break;

case 2: menucola(); break;

 case 3: menuordenamiento() ; break;

case 4: menubusqueda(); break;

case 5: menurecurividad(); break;

case 6: menulistas(); break;

case 7: exit(0); break;

/*------------------------------------------MENU PILA-------------------------------------------------*/

void menupila()

opc=0; //opciones del menu

while (opc != 4)

clrscr();

cout<<"\t Menu Pila\n";

cout<<"1. Adicionar pila\n";

cout<<"2. Eliminar pila\n";

cout<<"3. Mostrar pila\n";

cout<<"4. Regresar\n";
 cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MENU PILA /////////////////////////////////////////////////

case 1: agregar(); break;

case 2: eliminar(); break;

case 3: mostrar(); break;

case 4: menu(); break;

/*------------------------------------------MENU COLA----------------------------------------------*/

void menucola()

opc=0;

while (opc != 4)
{

clrscr();

cout<<"\t Menu Cola\n";

cout<<"1. Adicionar cola\n";

cout<<"2. Eliminar cola\n";

cout<<"3. Mostrar cola\n";

cout<<"4. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MENU COLA /////////////////////////////////////////////////

case 1: agregarcola() ; break;

case 2: eliminarcola() ; break;

case 3: mostrarcola() ; break;

case 4: menu(); break;

}
}

/*-------------------------------------MENU ORDENAMIENTO-----------------------------------------*/

void menuordenamiento()

opc=0;

while (opc !=3)

clrscr();

cout<<"\t Menu ordenamiento\n";

cout<<"1. Insercion\n";

cout<<"2. Burbuja\n";

cout<<"3. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE ORDENAMIENTO /////////////////////////////////////////////////

 case 1: ordenainsercion(); break;

case 2: ordenamiento_burbuja(); break;

case 3: menu(); break;

/*-------------------------------------MENU BUSQUEDA-----------------------------------------*/

void menubusqueda()

opc=0;

while (opc !=3)

clrscr();

cout<<"\t Menu busqueda\n";

cout<<"1. Secuencial\n";

cout<<"2. Binario\n";

cout<<"3. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;
 switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? BUSQUEDAS /////////////////////////////////////////////////

case 1: busquesecuencial(); break;

case 2: busquebinaria() ; break;

case 3: menu(); break;

/*-------------------------------------MENU RECURSIVIDAD-----------------------------------------*/

void menurecurividad()

opc=0;

while (opc !=4)

clrscr();

cout<<"\t Menu recursividad\n";

cout<<"1. Suma elementos de un vector\n";

 cout<<"2. Minimo comun multiplo\n";

cout<<"3. Elemento mayor de une vector\n";

cout<<"4. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE RECURSIVIDAD /////////////////////////////////////////////////

case 1: recursumavector(); break;

case 2: comunmultiplo(); break;

case 3: elementomayor(); break;

case 4: menu(); break;

/*----------------------------------------------MENU LISTAS------------------------------------------*/

void menulistas()
{

while (opc != 4)

clrscr();

cout<<"\t Menu Listas\n";

cout<<"1. Listas sencillas\n";

cout<<"2. Listas Circulares\n";

cout<<"3. Listas doblemente enlazadas\n";

cout<<"4. Vovler\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE LISTAS /////////////////////////////////////////////////

case 1: menulistassimples(); break;

case 2: menulistascirculares(); break;

case 3: menulistasdobles(); break;

case 6: menu(); break;

}
 }

/*------------------------------------------MENU LISTAS SENCILLAS-------------------------------------------------*/

void menulistassimples()

opc=0;

while (opc != 4)

clrscr();

cout<<"\t Menu Listas Sencillas\n";

cout<<"1. Adicionar\n";

cout<<"2. Eliminar\n";

cout<<"3. Mostrar\n";

cout<<"4. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

{
 case 1:

/* ---------- SUB MENU ADICIONAR SENCILLAS -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Adicionar Listas Sencillas\n";

cout<<"1. Adicionar Inicio\n";

cout<<"2. Adicionar Final\n";

cout<<"3. Adicionar Valor\n";

cout<<"4. Adicionar Posicion\n";

cout<<"5. Volver\n";

cout<<"ingrese opcion :";

cin>>opcl;

switch (opcl)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE LISTAS SENCILLAS /////////////////////////////////////////////////

case 1: adicionar_inicio_sencilla(); break;

 case 2: adicionar_final_sencilla(); break;

case 3: adicionar_valor_sencilla(); break;

case 4: adicionar_posicion_sencilla(); break;

case 5: menulistassimples(); break;

break;

case 2:

/* ---------- SUB MENU ELIMINARSENCILLAS -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Eliminar Listas Sencillas\n";

cout<<"1. Eliminar Inicio\n";

cout<<"2. Eliminar Final\n";

cout<<"3. Eliminar Valor\n";

cout<<"4. Eliminar Posicion\n";

cout<<"5. Volver\n";
 cout<<"ingrese opcion :";

cin>>opcl;

switch (opcl)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE ELIMINACIO EN LISTAS SENCILLAS //////////////////////////////////////

case 1: eliminar_inicio_sencilla(); break;

case 2: eliminar_final_sencilla(); break;

case 3: eliminar_valor_sencilla(); break;

case 4: eliminar_posicion_sencilla(); break;

case 5: menulistassimples(); break;

break;

case 3: mostrar_lista_sencilla(); break;

case 4: menulistas(); break;

}
/*------------------------------------------MENU LISTAS CIRCULARES-------------------------------------------------*/

void menulistascirculares()

opc=0;

while (opc != 4)

clrscr();

cout<<"\t Menu Listas Circulares\n";

cout<<"1. Adicionar\n";

cout<<"2. Eliminar\n";

cout<<"3. Mostrar\n";

cout<<"4. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)

case 1:
/* ---------- SUB MENU ADICIONAR CIRCULARES -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Adicionar Listas Circulares\n";

cout<<"1. Adicionar Inicio\n";

cout<<"2. Adicionar Final\n";

cout<<"3. Adicionar Valor\n";

cout<<"4. Adicionar Posicion\n";

cout<<"5. Volver\n";

cout<<"ingrese opcion :";

cin>>opcl;

switch (opcl)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE LISTAS CIRCULARES /////////////////////////////////////////////////

case 1: adicionar_inicio_circular(); break;

case 2: adicionar_final_circular(); break;

 case 3: adicionar_valor_circular(); break;

case 4: adicionar_posicion_circular(); break;

case 5: menulistascirculares(); break;

break;

case 2:

/* ---------- SUB MENU ELIMINAR CIRCULARES -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Eliminar Listas Circulares\n";

cout<<"1. Eliminar Inicio\n";

cout<<"2. Eliminar Final\n";

cout<<"3. Eliminar Valor\n";

cout<<"4. Eliminar Posicion\n";

cout<<"5. Volver\n";

cout<<"ingrese opcion :";

 cin>>opcl;

switch (opcl)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE ELIMINACION EN LISTAS CIRCULARES ////////////////////////////////////

case 1: eliminar_inicio_circular(); break;

case 2: eliminar_final_circular(); break;

case 3: eliminar_valor_circular(); break;

case 4: eliminar_posicion_circular(); break;

case 5: menulistascirculares(); break;

break;

case 3: mostrar_lista_circular(); break;

case 4: menulistas(); break;

}
}

/*------------------------------------------MENU LISTAS DOBLES-------------------------------------------------*/

void menulistasdobles()

opc=0;

while (opc != 4)

clrscr();

cout<<"\t Menu Listas Dobles\n";

cout<<"1. Adicionar\n";

cout<<"2. Eliminar\n";

cout<<"3. Mostrar\n";

cout<<"4. Regresar\n";

cout<<"ingrese opcion :";

cin>>opc;

switch (opc)
{

case 1:

/* ---------- SUB MENU ADICIONAR DOBLE -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Adicionar Listas Dobles\n";

cout<<"1. Adicionar Inicio\n";

cout<<"2. Adicionar Final\n";

cout<<"3. Adicionar Valor\n";

cout<<"4. Adicionar Posicion\n";

cout<<"5. Volver\n";

cout<<"ingrese opcion :";

cin>>opcl;

switch (opcl)

{
 ///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE ADICIONAR EN LISTAS
DOBLES /////////////////////////////////////////////////

case 1: adicionar_inicio_doble(); break;

case 2: adicionar_final_doble(); break;

case 3: adicionar_valor_doble(); break;

case 4: adicionar_posicion_doble(); break;

case 5: menulistasdobles(); break;

break;

case 2:

/* ---------- SUB MENU ELIMINAR DOBLE -------- */

opcl=0;

while (opcl != 5)

clrscr();

cout<<"\t Menu Eliminar Listas Dobles\n";

cout<<"1. Eliminar Inicio\n";

cout<<"2. Eliminar Final\n";

 cout<<"3. Eliminar Valor\n";

cout<<"4. Eliminar Posicion\n";

cout<<"5. Volver\n";

cout<<"ingrese opcion :";

cin>>opcl;

switch (opcl)

///////////////LLAMADO A LAS FUNCIONES DEL MEN? DE ELIMINAR EN LISTAS DOBLES /////////////////////////////////////////////////

case 1: eliminar_inicio_doble(); break;

case 2: eliminar_final_doble(); break;

case 3: eliminar_valor_doble(); break;

case 4: eliminar_posicion_doble(); break;

case 5: menulistasdobles(); break;

break;
 case 3: mostrar_lista_doble(); break;

case 4: menulistas(); break;

/* ********************************************************************************************* */

void agregar(){

Aux=new nodop;

cout<<"ingrese datos"<<endl; ///SE PIDE AL USUARIO INGRESAR UN DATO

cin>> Aux->info; ///SE LEE EL DATO INGRESADO POR EL USUARIO

if(Cab==NULL){ //SE AGREGA UN CONDICIONAL POR SI CABECERA EST? VACIA

Cab=Aux;

Cab->ant=NULL;

else { // SI CABECERA TIENE POR LO MENOS ENTONCES SE PROCEDE A ASIGNAR EL DATO A UN NODO SIGUIENTE

Aux->ant=Cab;

Cab=Aux;
 }

/*************************************FUNCION PARA ELIMINAR PILA**************************************/

void eliminar(){

if(Cab==NULL){ ////////////SE COMPRUEBA QUE LA PILA ESTE VACIA O NO///////////////////////

cout<<"La pila esta vacia"<<endl;

else{

if(Cab->ant==NULL){ //////////SI LA PILA TIENE POR LO MENOS UN DATO, ENTONCES SE PROCEDE A HACER LA
ELIMINACION

cout<<"Se Elimino: " << Cab->info<<endl; //////////SE ELIMINA EL ULTIMO DATO INGRESADO/////////////

delete Cab; //////////SE ELIMINA EL DATO DE CABECERA/////////////

Cab=NULL; ////////// LA PILA QUEDA VACIA////////////////

else{ ///////SI LA PILA TIENE VARIOS DATOS SE ELIMINA EL ULTIMO DATO INGRESADO/////////

Aux=Cab;

Cab=Cab->ant;

cout<<"se elimino " << Aux->info<<endl;

delete Aux; /////////// SE ELIMINA LA VARIABLE AUXILIAR O EL ULTIMO DATO DE LA PILA///////

 }

system("PAUSE");

/***************************************FUNCION PARA MOSTRAR PILA**********************************************/

void mostrar(){

if(Cab==NULL){ ///SI LA PILA ESTA VACIA ////////////

cout<<"no hay ningun dato"; /// ENTONCES SE EMITE UN MENSAJE ACLARANDOLO///////////

else{ //////SI LA PILA TIENE POR LO MENOS UN DATO///////

Aux=Cab;

while(Aux!=NULL){ ///// ENTONCES SE PROCEDE A IMPRIMIR LOS DATOS O ELEMENTOS DE LA PILA/////////

cout<<Aux->info<<endl;

Aux=Aux->ant;

system("PAUSE>NULL");

}
/*******************************************************COLAS***************************************************/

void agregarcola(){

Auxiliar=new cola;

cout<<"ingrese datos para la cola"<<endl; //////////SE PIDE AL USUARIO INGRESAR ELEMENTO A LA COLA//////

cin>> Auxiliar->dato; ////////////////////////SE LEE EL DATO INGRESADO POR EL USUARIO/////////////

if(Cabecera==NULL){ ///// SI LA COLA ESTA VACIA ////////////

Cabecera=Ultimo=Auxiliar; //////ENTONCES CABECERA Y ULTIMO DATO SERA EL MISMO////////

else { /////SI LA COLA TIENE POR LO MENOS UN DATO//////////

Ultimo->siguiente=Auxiliar; ////EL DATO INGRESADO APUNTA HACIA SIGUIENTE///////////

Ultimo=Auxiliar;

Ultimo->siguiente=NULL; //////////////////////////////////////////////////////

//////////////////////////////////FUNCION PARA ELIMINAR DATO DE LA COLA//////////////////////////////////////////////////////

void eliminarcola(){

if(Cabecera==NULL){ ////////////////// SE COMPRUEBA CON UN CONDICIONAL QUE LA COLA ESTE VACIA O NO//////////////

cout<<"La cola esta vacia"<<endl;////////////////// SI ESTA VACIA ENTONCES SE IMPRIME ESTE MENSAJE///////////////
 }

else{ //////////SI LA COLA TIENE POR LO MENOS UN DATO ENTONCES//////////////

if(Cabecera==Ultimo){ ///////CONDICIONAL SI LA COLA SOLO TIENE UN DATO//////////////

cout<<"Se Elimino: " <<Cabecera->dato<<endl; ////////////SE ELIMINA Y LA COLA QUEDA VACIA//////////////

delete Cabecera; //////////////////SE ELIMINA EL DATO, COMO SE TRATA DE COLA ENTONCES ESE DATO ES EL PRIMER
DATO INGRESADO///

Cabecera=NULL;

else{ /////////////// SI CABECERA TIENE MAS DE UN DATO//////////////////

Auxiliar=Cabecera;

Cabecera=Auxiliar->siguiente; ////////// SE INTERCAMBIAN DATOS EN POSICIONES DE NODO DIFERENTES/////////

cout<<"se elimino " << Auxiliar->dato<<endl; /////////SE PROCEDE A HACER LA ELIMINACION DEL PRIMER DATO DE LA
COLA//////

delete Auxiliar;

system("PAUSE");

cout<<endl;
}

//////////////////////////////////////////FUNCION PARA MOSTRAR LA COLA//////////////////////////////

void mostrarcola(){

if(Cabecera==NULL){ ////////////CON ESTE CONDICIONAL SE COMPRUEBA QUE LA COLA ESTE VACIA O NO//////////

cout<<"no hay ningun numero de cedula para mostrar"<<endl;//////// SI ESTA VACIA SE IMPRIME ESTE MENSAJE EN
PANTALLA////////

else{ /////////////SI LA COLA TIENE POR LO MENOS UN DATO ENTONCES...../////////////////

Auxiliar=Cabecera;

while(Auxiliar!=NULL){ /////////CICLO REPETITICO HASTA QUE EL DATO AUXILIAR SEA UN DATO VACIO O NULL//////////////

cout<<Auxiliar->dato<<endl; /////////////SE IMPRIMEN UNO A UNO LOS DATOS DE LA COLA/////////////

Auxiliar=Auxiliar->siguiente; /////////AUXILIAR VA AVANZANDO DE NODO A NODO SIGUIENTE PARA SER IMPRESO EN EL

PROXIMO CICLO//////

system("PAUSE");

/* -----*********---------**********---- FUNCIONES ORDENAMIENTO------********-----------*****--- */

/*--------------------------------ORDENAMIENTO INSERCION-----------------------------------------*/

void ordenainsercion()

int v[50], N, i, j, temporal, ele;

clrscr();

cout<<"\tOrdenamiento Por Insercion\n";

cout<<"digite tama?o del vector:\n"; //////////SE PIDE AL USUARIO INGRESAR LA MAGNITUD DEL
VECTOR//////////////////////////////////////

cin>> N; //////////SE PROCEDE A LEER LA MAGNITUD O TAMA?O DEL VECTOR//////////////////////////////////

cout<<"dijite los elementos del vector\n";

for (i = 0; i< N; i++)

cin>>ele; ////////////////////////////SE LEEN LOS DATOS O ELEMENTOS INGRESADOS POR EL USUARIO/////////////

v[i]=ele; ///////////SE GUARDAN LOS DATOS EN LAS POSICIONES DEL VECTOR/////////////

cout<<"este es tu vector:\n";

for (i = 0; i < N; i++)

cout<< v[i] << " "; ///////////SE MUESTRA EL VECTOR COMPLETO QUE EL USUARIO INGRESO////////////

}
for (i = 1; i < N; i++)

temporal = v[i];

for (j = i; j > 0 && v[j - 1] > temporal; j--) //////SE AGREGA UN CONFDICIONAL///////

v[j] = v[j - 1];

v[j] = temporal;

cout<<"\n y este tu vector ordenado:\n";

for (i = 0; i < N; i++ )

cout<< v[i] << " "; ///////////SE MUESTRA EL VECTOR ORDENADO/////////////

getch();

/*-------------------------------ORDENAMIENTO BURBUJA-------------------------------------------*/
void ordenamiento_burbuja()

{int n,aux;

cout<<"?Cuantos numeros desea ingresar?"<<endl;

cin>> n; ////////////////////////////////////SE LEE EL TAMA?O DEL VECTOR///////////

int v[n]; ////////////VECTOR DEL TAMA?O N.. N LO PROPORCIONO EL USUARIO////////////

for (int i=0;i<n;i++)

cout<<"Ingrese el valor de la posicion "<<i+1<<endl;

cin>>v[i]; //////////////////////////SE PIDE EL VALOR DEL VECTOR DESDE 0 HASTA N//////////

cout<<" \n Numeros ordenados de menor a mayor"<<endl;

for (int i=0;i<n;i++) ////////////////////////SE PLICA EL METODO DE BURBUJA/////////////

for(int j =0; j <n-1; j++)

if ( v[j]>v[i]) /////////////////SE AGREGA UN CONDICIONAL////////////////////////

 {

aux = v[i]; ///////////////////AUXILIAR TOMA VALORES PARA INTERCAMBIAR LOS ELEMENTOS ASCENDENTEMENTE//////////

v[i]=v[j];

v[j]=aux;

for (int i=0;i<n;i++)

cout<<" "<<v[i]<<endl; //////////////////////SE IMPRIMEN LOS NUMEROS DE MENOR A MAYOR////////

getch();

/* ********************************************************************************************* */

/* -----*********---------**********---- FUNCIONES BUSQUEDA ------********-----------*****--- */

/*-------------------------------------- BUSQUEDA SECUENCIAL ----------------------------------*/

void busquesecuencial()

int a[50], pos, temp, i, n, j, num;

clrscr();

cout<<"\tBusqueda secuencialt\n";

cout<<"digite el numero de elementos\n";

cin>> n; //////////SE LEE EL NUMERO DE ELEMENTOS DEL VECTOR////////////

for (i=0; i< n; i++) { //////////////CICLO REPETITIVO DESDE 0 HASTA LA POCICION N///////////

cout<<"digite un elemento\n";

cin>>a[i]; } ////////////////SE INGRESAN ELEMENTOS UNO A UNO////////

cout<<"El vector es:"<<endl;

for (i=0; i< n; i++) {

cout<<" "<<a[i]; } /////////////SE IMPRIME EL VECTOR DE LA MISMA MANERA QUE SE INGRESO/////////////

cout<<endl;

bool bandera=false; /////////SE CREA UN TIPO BOOL PARA ALERTAR CUANDO SE ENCUENTRE EL NUMERO A BUSCAR///////////

cout<<"Ingrese El Elemento A Buscar"<<endl;

 cin>>num; ////////////SE INGRESA EL NUMERO A BUSCAR////////////

i=0;

while((bandera==false)&&(i<n)){//////////////MIENTRAS LA VARIABLE BOOL SEA FALSA ENTONCES SE SIGUE CUMPLIENDO EL CICLO////

if(a[i]==num){ ///////// SI EL VECTOR ES IGUAL AL NUMERO A BUSCAR....//////////

bandera=true; ////////// ENTONCES LA BANDERA CAMBIA DE FALSO A VERDADERO///////////

break;

i++;

if(bandera == false){ /////SI LA BANDERA DESPUES DE TODO SIGUI SIENDO FALSA, NO SE ENCONTRO EL ELEMENTO O NO EXISTE DENTRO
DEL ARREGLO

cout<<"El Elemento No Existe En El Vector"<<endl; ////////////MENSAJE*********///////////////

else if(bandera ==true){ ///////////// SI LA BANDERA CAMBIO A VERDADERO SE IMPRIME LA POSICION DEL NUMERO A BUSCAR//////////

cout<<"El Numero Esta En La Posicion "<<i+1<<" Del Vector"<<endl;

}
 getch(); ////////////////// ESPERANDO TECLA ALEATORIA PRESIONADA POR EL USUARIO//////////

/*------------------------------------- BUSQUEDA BINARIA ------------------------------------*/

void ingresarArreglo(float A[max],int n)

int i;

for(i=0;i<n;i++)

cout<<" A["<<i+1<<"]=";

cin>>A[i]; //////////////////USUARIO INGRESA LOS DATOS EN CADA POSICION DEL ARREGLO////////////

cout<<endl; ///////////// SALTO DE LINEA///////

void reportarVector(float V[max],int n)

int i;

for(i=0;i<n;i++)//recorre el arreglo

cout<< V[i]<<"\t";
 }

cout<<endl<<endl;

//*************funcion de ordenacion por el metodo de seleccion *****************//

void ordenarSeleccion(float V[max],int n)

int i,j,k;

float temp;

for(i=0;i<n-1;i++)

k=i;

temp=V[i];//el primer valor del arreglo lo asignamos a un temporal

// para luego compararlo con los demas valores del arreglo hasta encontrar el menor valor

for(j=i+1;j<n;j++)

if(V[j]<temp)// si encontramos un valor que sea menor que el primer valor del arreglo (temp)

//entonces intercambiamos de posicion,los mismos pasos se repetira hasta que arreglo sea ordenado completamente

k=j;
 temp=V[j];

V[k]=V[i] ;

V[i]=temp;

//*********funcion de busqueda binaria,solo funiona para arreglos ordenados*******************//

int busquedaBinaria(float V[max],int n ,int dato)

int mitad,izq,der;

izq=0;

der=n-1;

while(izq<=der)//el elemento que esta ala izquierda debe de ser menor que el de la derecha

{mitad=(izq+der)/2;//calculamos el elemento central del arreglo hasta encontrar el valor buscado

if(dato>V[mitad])//si el elemento buscado es mayor que el centro entonces buscamos en la segunda mitad del arreglo

izq=mitad+1;//el primer valor del arreglo pasa hacer la mitad mas 1

else if(dato<V[mitad])//si el elemento buscado buscado es menor que la mitad entonces buscamos en la primera mitad del arreglo

der=mitad-1;

else return mitad; //retornamos el elementoencontrado

 }

return -1;//el elemento no existe en el arreglo

int busquebinaria()

float A[max]; ////////SE CREA UN DATO TIPO FLOAT///////////////

int n,p=0,dato;

int pos;

clrscr();

cout<<"\tBusqueda binaria\n";

cout<<"ingrese numero de elementos :";

cin>>n;

ingresarArreglo(A,n); /////////////SE AGREGA UN ARREGLO EN BUSQUEDA BINARIA///////////

cout<<"vector ingresado"<<endl;

reportarVector(A,n);

ordenarSeleccion(A,n);

cout<<"el vector ordenado:"<<endl;

reportarVector(A,n);
 ////// SE INGRESA , REPORTA Y SE ORDENA LOS VECTORES///////

cout<<"ingrese numero a buscar:";

cin>>dato;

pos=busquedaBinaria(A,n,dato); ////////////BUSQUEDA BINARIA//////////////

{ if(pos ==-1) ////CONDICIONAL SI DONDE DICE SI LA POSICION ES IGUAL A 1 ////////////

cout<<"el dato no esta en el arreglo"<<endl;

else

cout<<"el dato se encontro en la posicion:"<<pos+1 <<endl;

getch();

/* ********************************************************************************************* */

/* -----*********---------**********---- FUNCIONES RECURSIVIDAD ------********-----------*****--- */

/*--------------------------------------RECURSIVIDAD SUMA DE ELEMENTOS DE UN VECTOR ----------------------*/

int recursumavector()
{

int i, n, re;

clrscr();

cout<<"\tSUMA DE ELEMENTOS DE UN VECTOR\n"; /////////////////SE SUMA LOS ELEMENTOS DEL VECTOR////////////////

cout<<"Digite el tama�o del vector";

cin>>n;

for (i=0; n>i; i++) ///////////CONDICIONAL DONDE SE AGREGA UN DATO QEU SERA IGUAL A 0, EL DATO SERA MENOR QUE EL TAMAÃ'O DEL
VECTOR Y VA DE UNO EN UNO//////////

cout<<"Inserte un elemento del verctor";

cin>>t[i];

re=sumaVector(t,n); ////////LA RESPUESTA SERA IGUAL A LA SUMA DE VECTORES////////

cout<<"Resultado de la suma recursiva: "<<re;

getch();

return 0;

int sumaVector(int t[], int n) ////////SE SUMAN LOS VECTORES//////

{
 int r = 0;

if(n==0){

r += t[0];

}else{

r = t[n] + sumaVector(t,n-1);

return r;

/*------------------------------------------RECURISVIDAD MCM-----------------------*/

int comunmultiplo()

int n1, n2;

int result; ////////NUEVOS ELEMENTO TIPO ENTERO

clrscr();

cout<<"\tMinimo comun multiplo\n"; /////////MINIMO COMUN MULTIPLO///////

cout<<"Valores: \n";
cin>>n1;

cin>>n2;

result=mcm(2,n1,n2); ///////// EL RESULTADO SERA IGUAL A LOS ELEMNTOS INGRESADOS ANTERIORMENTE//////

cout<<"El minimo com�n m�ltiplo es: \n"<<result;

getch();

return 0;

int mcm(int div, int n1, int n2){

int aux=1;

while(n1%div==0 || n2%div==0){ //////UN CICLO REPETITIVO DONDE SE HACE UNA COMPARACION DE DIVICION////////

aux*=div;

if(n1%div==0) ///////NUEVO CONDICIONAL DONDE EL NUMERO SERA DIVIDIDO Y TENDRA QUE DAR IGUAL A 0/////////

n1/=div;

if(n2%div==0)

n2/=div; ////////// SI SE CUMPLE ESTA FUNCION EL CONDICIONAL FUNCIONARA SINO SE AGREGA OTRO CONDICIONAL///////

if(div<=n1||div<=n2)

aux*=mcm(div+1,n1,n2);

return aux;
}

/*---------------------------- RECURSIVIDAD ELEMENTO MAYOR DEL UN VECTOR-------------------------*/

int verElementoMayor(int n,int pos)

if(n>9) return pos; ///////////// CONDICIONAL DONDE N SERA MAYOR A EL NUMERO 9 QUE SERIA EL NUMERO TOTAL DE LAS POSICION//////

else

if(pos>arr[n]) ///////SI LA POCISION APUNTAR A ARRAY ENTONCES ELIMINARA EL ELEMNTO MAYOR///////

return verElementoMayor(n+1,pos);

else return verElementoMayor(n+1,arr[n]);

void elementomayor() //////////ELIMINAR EL ELEMNTO MAYOR/////////

int t, i;

clrscr();
 cout<<"\tElemento mayor de un vector\n"; /////////SE ELIMINA EL NUMERO MAYOR DEL VECTOR////////

cout<<"Digite el tama�o del vector " ; //////////SE PIQUE QUE EL USUARIO INGRESE TAMAÃ'O//////

cin>>t;

for (i=0; t>i; i++) ////////NUEVO CICLO////////////

cout<<"Digite un elemento "; ///////NUEVAMENTE SE PIDE QUE EL USUARIO INGRESE UN ELEMENTO/////

cin>>arr[i];

cout<<"el numero mayor es: "<< verElementoMayor(0,arr[0]);

getch();

/* ********************************************************************************************* */

/* -----*********---------**********---- LISTAS ------********-----------*****--- */

/* ################################ SENCILLA ##########################*/

/* ------------------------------------ ADICIONAR AL INICIO sencilla---------------*/

void adicionar_inicio_sencilla()

{
 aux=new(nodo); ///////SE AÃ'ADE UN NUEVO NODO///////

cout<<"digite el valor"; /////////SE PIDE QUE INGRESE UN VALOR///////

////////SI ESTA VACIA ENTONCES ///////

cin>>aux->info;

if (cab==NULL) ///////////SE HACE UNA COMPARACION DONDE CABESERA SERA IGUAL A NULL/////////

cab=aux;////////// CABECERA SE CORRRERA UNA POCISION DONDE ESTA EL NODO CREADO/////////

ult=aux;

ult->sig=NULL;

else //////SINO SE CUMPLE LA FUNCION SI ENTONCES ENTRARA A EL SINO//////

aux->sig=cab;

cab=aux;

ult->sig=NULL;

///////SIMPLEMENTE EL SINO LO QUE HACE ES QUE EL ELEMNTO QUE ESTA EN EL NODO SERA RODADA UNA O CUNTAS VECES PARA QUE
EL NUEVO VALOR INGRESADO SE COLOQEU DE PRIMERO/////

}
/* ------------------------------------ ADICIONAR AL FINAL SENCILLA---------------*/

void adicionar_final_sencilla()

aux=new(nodo); //////SE AGREGA UN NUEVO NODO//////

cout<<"digite el valor";/////SE PIDE QUE SE INGRESE UN VALOR/////

cin>>aux->info;

if (cab==NULL) //////SI CABERCERA ESTA VACIA///////

cab=aux;

ult=aux;

ult->sig=NULL;

////////////ULTIMO APUNTARA A SIGUIENTE Y SIGUIENTESERA IGUAL A NULL//////////

else

ult->sig=aux; ////////ULTIMO APUNTARA A SIGUIENTE Y EL VALOR INGRESADO SERA COLOCADO EN EL NODO CREADO///////

ult=aux;

ult->sig=NULL;
 }

/* ------------------------------------ ELIMINAR AL INICIO SENCILLA---------------*/

void eliminar_inicio_sencilla()

if(cab==NULL) ////////LA LISTA ESTA VACIA///////

cout<<"Lista vacia";

else

if(cab==ult)

free(cab); ///////SE LIBERA ESPACIO /////

cab=NULL; ///////ESTAS ESTAN VACIAS //////

ult=NULL;

else

p=cab;
 cab=cab->sig; ///////////CABERCERA SERA IGUAL A VALOR INGRESADI /////////

cout<<"Ha sido eliminado el valor del inicio:"<<p->info; ///////////SE ELIMINA EL VALOR DEL INICIO/////////

free(p); /////LIBERA ESPACIO/////

getch();

/* ------------------------------------ ELIMINAR AL FINAL SENCILLA---------------*/

void eliminar_final_sencilla()

if(cab==NULL) ///////CONDICIONAL DONDE LA LISTA EST VACIA////////

cout<<"Lista vacia";

else

if(cab==ult) /////////SI CABERCERA ES IGUAL A ULTIMO /////////

free(cab); /////LIBERA ESPACIO/////

 cab=NULL;

ult=NULL;

else

p=cab;

while(p->sig!=ult) //////UN CICLO DONDE P PUNTA A SIGUIENTE Y ESTE SERA DIDIFERNE DE ULTIMO /////

p=p->sig; //////P SERA IGUAL A P DONDE P APUNTARA A SIGUIENTE //////

cout<<"Ha sido eliminado el valor del final:"<<ult->info;

free(ult); //////SE LIBERA UN ESPACIO//////

ult=p;

ult->sig=NULL; /////ULTIMO APUNTARA A SIGUIENTE Y ESTE APUNTA A NULL//////

getch();

/*------------------------------------- MOSTRAR LISTA SENCILLA ------------------*/

void mostrar_lista_sencilla()

clrscr(); /////ESTA FUNCION NO RETORNA NINGUN VALOR//////

int nume=0; ///////SE CREA UN UEVO VECTOR///////

if(cab==NULL) ////////SI CABECERA ESTA VACIA///////

cout<<"Lista vacia";

getch();

else

cout<<"Esta es la lista\n"; /////////MUESTRA MENSAJE DONDE DIGA EN QUE ESTA LA LISTA /////////

p=cab;

while(p!=NULL) ///////MIENTRAS QUE P SEA DIFERENTE DE NULL OSEA MIENTRAS QUE P NO ESTE VACIA//////

cout<<nume<<". "<<p->info<<"\n"; ///////SE MOSTRARA EL NUMERO Y P APUNTARA A IFORMACION////////

p=p->sig;

nume++;

}
 getch();

/*------------------------------------- ADICIONAR POR VALOR SENCILLA ------------------*/

void adicionar_valor_sencilla()

if (cab==NULL) //////////SI CABECERA ESTA VACIA/////////

cout<<"Lista vacia"; ////LA LISTA ESTA VACIA/////

getch();

else

cout<<"digite el valor"; //////////SE DIGITA UN VALOR////////

cin>>valor; ///////SE IMPRIME VALOR///////

if(valor==cab->info) ///////SI VALOR ES IGUAL A CABECERA ESTE APUNTARA A INFO///////

adicionar_inicio_sencilla(); //////ADICIONA AL INICIO//////

}
 else

p=cab;

while(p!=NULL && p->info!=valor) ///// MIENTRAS P NO ETSE VACIA TENDRA UN PARAMETRO Y ESTE APUNTA AINFO Y SERA DIFERNTE A
VALOR//////

p=p->sig; ///////P SERA IGUAL A P Y ESTE APUNTARA A SIGUIENTE////////

if(p==NULL) ////////SI P ESTA VACIA////////

cout<<"Valor no encontrado"; ///////QUE DIGA QUE NO SE ENCONTRO EL VALOR//////

getch();

else

q=cab;

while(q->sig!=p) //////MIENTRAS QUE Q APUNTE A SIGUIENTE Y ESTE SEA DIFERNETE A P///////

q=q->sig; ////////Q SERA IGUAL A Q Y ESTE APUNTARA A SIGUIENTE///////

}
 aux=new(nodo); ////////SE CREA UN NUEVO NODO/////////

cout<<"digite la informacion"; ////////SE DIJITA LA INFORMACION A BUSCAR ////////

cin>>aux->info; /////////SE LEE EL NUEVO NODO QUE DARA LA INFORMACION DIGITADA/////////

q->sig=aux;

aux->sig=p;

/*------------------------------------- ADICIONAR POR VALOR SENCILLA ------------------*/

void adicionar_posicion_sencilla()

cout<<"Digite posicion"; ////////DIGITE LA POCISION///////

cin>>pos; //////SE LEE LA POCISION//////

if(pos==1) ///////SI POCISION ES IGUAL A 1///////

adicionar_inicio_sencilla();

else
{

if(cab==NULL) ///////SI CABECERA ESTA VACIA////////

cout<<"Lista vacia"; ///////LA LISTA ESTA VACIA ////////

getch();

else

cont=0; ///////UN CONTADOR PARA LAS LITAS/////////

p=cab;

while(p!=NULL) ////////MIENTRAS QUE P NO ESTE VACIA////////

p=p->sig; ///////P SERA IGUAL A P///////

cont++;

if(pos==cont+1)

adicionar_final_sencilla();

else
{

if(pos<1||pos>cont+1) ///////SI POCISION VA A IR DE UNO EN UNO//////

cout<<"Posicion no valida, fuera de rango"; /////////EL VERIFICA QUE LA POCISION SE ENCUENTRE O NO///////

getch();

p=cab;

for(i=1;i<=pos;i++) //////PARA QUE I SEA IGUAL A 1 Y SEA MENPR O IGUAL QUE LA POCISION Y VAYA DE UNO EN UNO//////

p=p->sig;

q=cab;

while(q->sig!=p) ////////MIENTRAS Q VA A SIGUIENTE Y SEA DIFERENTE DE P/////////

q=q->sig;

aux=new(nodo); //////////SE CREA UN NUEVO NODO////////

cout<<"Digite la informacion"; //////DIGITA LA INFORMACION//////

cin>>aux->info; ////////LEA AUX APUNTA A INFORMACION///////

q->sig=aux;
 aux->sig=p;

/*------------------------------------- ELIMINAR POR VALOR SENCILLA ------------------*/

void eliminar_valor_sencilla()

if (cab==NULL)

cout<<"Lista vacia";

getch();

else

cout<<"digite el valor";///////SE LE PIDE AL USUSARIO QUE INGRESE UN VALOR////////

cin>>valor; ////////EL VALOR SE LEE//////

if(valor==cab->info) //////////EL VALOR SERA INGRESADO A CABECERA QUE APUNATARA A INFORMACION////////

 {

eliminar_inicio_sencilla();

else

p=cab;

while(p!=NULL && p->info!=valor) //////MIENTRAS QUE P NO ESTE VACIO EL APUNTARA A INFO QUE TENDRIA QUE SER DIFERENTE DE EL
VALOR INGRESADO//////

p=p->sig;

if(p==NULL)

cout<<"Valor no encontrado"; ////////////VALOR NO ENCONTRADO////////////

getch();

else

q=cab; ////////NUEVO NODO////

while(q->sig!=p) /////////MIENTRAS QHYE Q APUNTE A SIGUIENTE Y SERA DIFERENTE DE P///////

 {

q=q->sig;

q->sig=p->sig;

cout<<"Ha sido eliminado el valor:"<<p->info; ///////SE ELIMINARA EL VALOR INGRESADO ////////

free(p);//////LIBERA ESPACIO///////

getch();

/*------------------------------------- ELIMINAR POR VALOR SENCILLA ------------------*/

void eliminar_posicion_sencilla()

cout<<"Digite posicion"; ///////DIGITE LA POSICION DESEADA///////

cin>>pos;

if(pos==1) ///////LA POSICION SERA 1////////

eliminar_inicio_sencilla();
}

else

if(cab==NULL) //////////SI CAB ESTA VACIA/////////

cout<<"Lista vacia"; ////////DIGA LISTA VACIA////////

getch();

else

cont=0;

p=cab;

while(p!=NULL) ///////EL VALOR NO TENDRA QUE ESTAR VACIO/////

p=p->sig;

cont++;

if(pos==cont+1) //////UN CICLO DONDE LA POSICION VA A IR AUMENTANDO///////

eliminar_final_sencilla();
}

else

if(pos<1||pos>cont+1)

cout<<"Posicion no valida, fuera de rango"; //////POCISION NO VALIDA//////

getch();

p=cab;

for(i=1;i<=pos;i++) ////////PARA QUE I SEA IGUAL A 1 Y SEA MAYOR O IGUAL A POSICION Y VAYA DE 1 EN 1////////

p=p->sig;

q=cab;

while(q->sig!=p) //////MIENTRAS Q APUNTE A SIGU TENDRA QUE SER DIFERENTE DE P//////

q=q->sig;

q->sig=p->sig;

cout<<"Ha sido eliminado el valor:"<<p->info; ////////SE ELIMINA EL VALOR INGRESADOS///////

 free(p);

getch();

/* ################################ CIRCULAR ##########################*/

/* ------------------------------------ ADICIONAR AL INICIO CIRCULAR---------------*/

void adicionar_inicio_circular()

auxc=new(nodoc); /////////SE AÑADE ESPACIO EN MEMORIA PARA UN NUEVO NODO/////////

cout<<"Digite valor"; //SE PIDE AL USUARIO INGRESAR UN NUMERO/////////

cin>>auxc->info;

if (cabc==NULL) /////SI NO HAY DATOS EN LA LISTA....

{
 cabc=auxc; ////SE TOMA EL VALOR INGRESADO COMO CABECERA

ultc=auxc; ///ULTIMO SERA IGUAL AL VALOR INGRESADO

ultc->sig=cabc; // ULTIMO QUE APUNTA A SIGUIENTE SERA IGUAL A CABECERA

else ///SI LA LISTA TIENE POR LO MENOS UN DATO...

auxc->sig=cabc; //AUXILIAR APUNTA HACIA CABECERA

cabc=auxc; //CABECERA AHORA SERA AUXILIAR

ultc->sig=cabc; //ULTIMO APUNTARA HACIA CABECERA

/* ------------------------------------ ADICIONAR AL FINAL CIRCULAR---------------*/

void adicionar_final_circular()

auxc=new(nodoc); /////////SE AÑADE ESPACIO EN MEMORIA PARA UN NUEVO NODO/////////

cout<<"digite el valor"; //SE PIDE AL USUARIO INGRESAR UN NUMERO/////////

cin>>auxc->info; ////////////SE LEE EL VALOR INGRESADO POR EL USUARIO///////

if (cabc==NULL) /////SI NO HAY DATOS EN LA LISTA....

{
 cabc=auxc; ////SE TOMA EL VALOR INGRESADO COMO CABECERA

ultc=auxc; ///ULTIMO SERA IGUAL AL VALOR INGRESADO

ultc->sig=cabc; // ULTIMO QUE APUNTA A SIGUIENTE SERA IGUAL A CABECERA

else ///SI LA LISTA TIENE POR LO MENOS UN DATO...

ultc->sig=auxc; /////ULTIMO QUE APUNTA A SIGUIENTE SERA AUXILIAR

ultc=auxc; ////AUXILIAR AHORA SE POSICIONA COMO ULTIMO

ultc->sig=cabc; //ULTIMO APUNTA HACIA CABECERA

/* ------------------------------------ ELIMINAR AL INICIO CIRCULAR---------------*/

void eliminar_inicio_circular()

if(cabc==NULL) ///SI NO HAY DATOS EN LA LISTA...

cout<<"Lista vacia"; ///SE EMITE UN MENSAJE QUE ESTA VACIA

getch();

}
 else ///SINO, SI LA LISTA TIENE POR LO MENOS UN DATO...

if(cabc==ultc) ////SI HAY SOLO UN DATO EN LA LISTA

free(cabc); //SE ELIMINA ESE UNICO DATO

cabc=NULL; ///CABECERA SE VACIA

ultc=NULL; ///ULTIMO SE VACIA

else ///SI HAY MAS DE UN DATO EN LA LISTA

pc=cabc; //EL AUXILIAR PC SE IGUALA A CABECERA

cabc=cabc->sig; //CABECERA AHORA SERA CABECERA QUE APUNTA A SIGUIENTE, ES DECIR SU PROXIMA POSICION EN LISTA

cout<<"Ha sido eliminado el valor:"<<pc->info; //MENSAJE QUE AVISA LA ELIMINACION DEL PRIMER ELEMENTO DE LA LISTA

free(pc); //SE HACE EFECTIVA LA ELIMINACION

ultc->sig=cabc; //ULTIMO APUNTA A CABECERA

getch(); //ESPERANDO TECLA

}
/* ------------------------------------ ELIMINAR AL FINAL CIRCULAR---------------*/

void eliminar_final_circular()

if(cabc==NULL) ///SI NO HAY DATOS EN LA LISTA...

cout<<"Lista vacia"; ///SE EMITE UN MENSAJE QUE ESTA VACIA

getch();

else ///SINO, SI LA LISTA TIENE POR LO MENOS UN DATO..

if(cabc==ultc) ////SI HAY SOLO UN DATO EN LA LISTA

free(cabc); //SE ELIMINA ESE UNICO DATO

cabc=NULL; ///CABECERA SE VACIA

ultc=NULL; ///ULTIMO SE VACIA

else ///SI HAY MAS DE UN DATO EN LA LISTA

pc=cabc; //EL AUXILIAR PC SE IGUALA A CABECERA

while(pc->sig!=ultc) //SE INICIA UN CICLO HASTA QUE PC->SIGUIENTE SEA DIFERENTE AL ULTIMO NODO
 {

pc=pc->sig; //PC IRA AVANZANDO DE POSICION EN CADA RECORRIDO DEL CICLO

cout<<"Ha sido eliminado el valor:"<<ultc->info; //MENSAJE QUE AVISA SA ELIMINACION DEL ULTIMO ELEMENTO DE LA LISTA

free(ultc); //SE HACE EFECTIVA LA ELIMINACION

ultc=pc; //ULTIMO TOMA EL VALOR DEL NODO PC

ultc->sig=cabc; //ULTIMO APUNTARA HACIA EL PRIMER ELEMENTO DE LA LISTA

getch();

/*------------------------------------- MOSTRAR LISTA CIRCULAR ------------------*/

void mostrar_lista_circular()

clrscr();

int nume=0;

if(cabc==NULL) /////////////SI LA LISTA ESTA VACIA ENTONCES SE PROCEDE AL CONDICIONAL/////

cout<<"Lista vacia";
 getch();

else //////////////// SI NO SE MANDA UN MENSAJE DONDE MUESTRE LOS ELEMENTOS DE LA LISTA/////////////////

cout<<"Esta es la lista\n";

pc=cabc;

while(pc!=ultc) ///////////////UN CICLO DONDE PC TIENE QUE SER DIFERENTE DE ULTIMO///////////

cout<<nume<<". "<<pc->info<<"\n"; ////////LO QUE MOSTRARA SERAN LOS DATO MIENTRAS DURE EL CICLO//////////

pc=pc->sig;

nume++;

cout<<nume<<". "<<ultc->info;

getch();

/*------------------------------------- ADICIONAR POR VALOR CIRCULAR ------------------*/

void adicionar_valor_circular()

{
 if (cabc==NULL)/////////////SI CABECERA ESTA VACIA ENTONCES SE PROCEDE A LISTA/////

cout<<"Lista vacia";

getch();

else

cout<<"digite el valor";////////SE PIDE Y LUEGO SE LEE EL VALOR //////////

cin>>valor;

if(valor==cabc->info) //SI VALOR INGRESADO ES IGUAL AL PRIMERO DE LA LISTA...

adicionar_inicio_circular(); /////ENTONCES SE LLAMA A LA FUNCION DE ELIMINAR INICIO////

else

pc=cabc->sig;

while(pc!=cabc && pc->info!=valor) ///////////////UN CICLO WHILE DONDE PC TIENE QUE SER DIFERENTE DE CABECERA Y DIFERENTE AL
VALOR INGRESADO///////////

pc=pc->sig; /////PC ES IGUAL A PC QUE APUNTA A SIG/////

 }

if(pc==cabc) //////SI PC ES IGUAL A CABECERA/////

cout<<"Valor no encontrado";////////LO QUE MUESTRARA SERA UN MSJ DICIENDO VALOR NO ENCONTRADO//////////

getch();

else

qc=cabc;

while(qc->sig!=pc) ///////////////UN CICLO WHILE DONDE QC APUNTARA A SIG QUE ES DIFERENTE A PC///////////

qc=qc->sig;

auxc=new(nodoc); ///////// DEFINE UN NUEVO NODO ///////

cout<<"digite la informacion"; ////////SALDRA UN MSJ SOLICITANDOLE AL USUARIO LA INFORMACION//////////

cin>>auxc->info;

qc->sig=auxc;

auxc->sig=pc;

}
 }

/*------------------------------------- ADICIONAR POR VALOR CIRCULAR ------------------*/

void adicionar_posicion_circular()

cout<<"Digite posicion";////////PEDIRA UNA POSION AL USUARIO//////////

cin>>valor;

cin>>valor;

cin>>pos;

if(pos==1)

adicionar_inicio_circular();

else

if(cabc==NULL) //////////SI LA LISTA ESTA VACIA ENTONCES SE PROCEDE AL CONDICIONAL/////

cout<<"Lista vacia";////// SE MOSTRARA UN MSJ LISTA VACIA//////

getch();
}

else //////////////// SI NO SE INICIALIZARA UN CONTADOR /////////////////

cont=1; ///CONTADOR///

pc=cabc->sig;

while(pc!=cabc) ///////////UN CICLO WHILE DONDE PC TIENE QUE SER DIFERENTE DE CABECERA///////////

pc=pc->sig; ////PC SERA IGUAL A PC QUE APUNTA A SIG//////

cont++;/// EL CONTADOR IRA INCREMENTADO DE 1////

if(pos==cont+1)

adicionar_final_circular();

else

if(pos<1||pos>cont+1)

cout<<"Posicion no valida, fuera de rango";

getch();
 }

pc=cabc;

for(i=1;i<=pos;i++)///////////UN CICLO FOR DONDE I ES IGUAL 1, I MENOR O IGUAL A POS QUE IRA INCREMENTANDO///////////

pc=pc->sig; ///PC IGUAL A PC QUE APUNTA A SIGUIENTE////

qc=cabc;

while(qc->sig!=pc)///////////////UN CICLO WHILE DONDE QC APUNTARA A SIG QUE SER DIFERENTE DE PC///////////

qc=qc->sig; ///////QC ESS IGUAL A QC QUE APUNTA A SIG/////

auxc=new(nodoc); //////SE CREA UN NUEVO NODO////

cout<<"Digite la informacion";

cin>>auxc->info; ////LEER NUEVO NODO AUXC QUE APUNTA A INFO/////

qc->sig=auxc; /////QC APUNTA A SIG QUE ES IGUAL A AUXC//////

auxc->sig=pc; //////AUXC QUE APUNTA A SIG Y ES IGUAL A PC//////

}
/*------------------------------------- ELIMINAR POR VALOR CIRCULAR ------------------*/

void eliminar_valor_circular()

if (cabc==NULL) /////////////SI CABECERA ESTA VACIA/////

cout<<"Lista vacia"; //////SE MOSTRARA UN MSJ LISTA VACIA//////

getch();

else //////////////// SI NO SE MANDA UN MENSAJE DONDE DIGA QUE EL ELEMENTO ESTA EN LA LISTA/////////////////

cout<<"digite el valor"; ////////LO QUE MUESTRARA SERA EL DATO QUE SE DIGITO POR PANTALLA//////////

cin>>valor;

if(valor==cabc->info) //////SI VALOR ES IGUAL A CABECERA QUE APUNTA A INFO////

eliminar_inicio_circular();

else //////////////// SI NO SE MANDA UN MENSAJE DONDE DIGA QUE EL ELEMENTO ESTA EN LA LISTA/////////////////

pc=cabc; //////PC ES IGUAL A CABECERA////

 while(pc!=NULL && pc->info!=valor) /////UN CICLO WHILE DONDE PC SERA DIFERENTE DE VACIA Y PC APUNTARA INFO QUE ES DIFERENTE
DE VALOR//////

pc=pc->sig; //////PC ES IGUAL A PC QUEAPUNTA A SIGUIENTE//////

if(pc==NULL) //////SI PC ESTA VACIO////

cout<<"Valor no encontrado";////UN MSJ DONDE DIRA VALOR NO ENCONTRADO//////

getch();

else

qc=cabc;

while(qc->sig!=pc)//////////UN CICLO WHILE DONDE QC APUNTARA SIGIENTE QUE ES DIFERENTE DE PC//////

qc=qc->sig; //////QC ES QC QUE APUNTA A SIGUIENTE//////

qc->sig=pc->sig; //////QC APUNTARA A ASIG QUE ES IGUAL A PC QUE APUNTA A SIG//////

cout<<"Ha sido eliminado el valor:"<<pc->info;

free(pc); ///// SE LIBERA ESPACIO EN LA MEMORIA///////

 getch();

/*------------------------------------- ELIMINAR POR POSICION CIRCULAR ------------------*/

void eliminar_posicion_circular()

cout<<"Digite posicion"; /////SE MOSTRARA DIGITE UNA POSICION//////

cin>>pos;

if(pos==1)

eliminar_inicio_circular();

else

if(cabc==NULL) /////////SI LA LISTA ESTA VACIA ENTONCES SE PROCEDE AL CONDICIONAL/////

cout<<"Lista vacia";
 getch();

else

cont=0; /////CONTADOR/////

pc=cabc; ////PC IGUAL A CABECRA////

while(pc!=NULL)//////////UN CICLO WHILE DONDE PC SERA DIFERENTE DE VACIA //////

pc=pc->sig; ////PC ES IGUAL A PC QUE APUNTA A SIG/////

cont++; ///CONTADOR IRA ICREMENTANDO////

if(pos==cont+1)

eliminar_final_circular();

else

if(pos<1||pos>cont+1)

cout<<"Posicion no valida, fuera de rango";//// SE MOSTRARA UN MSJ POSICION NO VALIDA////

 getch();

pc=cabc; /////PC IGUAL CABECERA///

for(i=1;i<=pos;i++) /////////UN CICLO FOR DONDE I ES IGUAL 1, I MENOR O IGUAL A POS QUE IRA INCREMENTANDO////////

pc=pc->sig; ////PC IGUAL A PC QUE APUNTA A SIGUIENTE////

qc=cabc;

while(qc->sig!=pc) /////UN CICLO WHILE DONDE QC APUNTARA SIG QUE ES DIFERENTE DE PC//////

qc=qc->sig;////QC IGUAL A QC QUE APUNTA A SIGUIENTE////

qc->sig=pc->sig; ////QC APUNTA A SIGUIENTE QUE ES IGUAL A PC QUE APUNTA A SIGUIENTE/////

cout<<"Ha sido eliminado el valor:"<<pc->info;

free(pc);///// SE LIBERA ESPACIO EN LA MEMORIA///////

getch();

}
/* ################################ DOBLES ##########################*/

/* ------------------------------------ ADICIONAR AL INICIO DOBLES---------------*/

void adicionar_inicio_doble()

auxd=new(nodod); ///////// DEFINE UN NUEVO NODO ///////

cout<<"Digite valor"; //// SE DIGITA UN VALOR///

cin>>auxd->info; ////SE LEE ESTE VALOR QUE APUNTA A INFO///

if (cabd==NULL)/////SE COMPARA SI ESTA VACIA////

cabd=auxd;////CABECERA SERA IGUAL AL NODO CREADO////

ultd=auxd;///ULTIMO SERA IGUAL AL NODO INGRESADO QUE TENDRA EL MISMO VALOR///

cabd->ant=NULL;///CABECERA QUE APUNTA A ANTERIOR QUE ES IGUAL A VACIO////

ultd->sig=NULL;///ULTIMO QUE APUNTA A SIGUIENTE QUE ES IGUAL A VACIO///

else

auxd->sig=cabd;///ULTIMO APUNTA A SIGUIENTE QUE ES IGUAL A CABECERA///

cabd->ant=auxd;/// CABECRA APUNTA A ANTETERIOR QUE ES IGUAL A AUXD///

 cabd=auxd;/// CABECERA ES IGUAL A AUXD//

cabd->ant=NULL;///CABECERA APUNTA A ANTERIOR QUE ES IGUAL A VACIO///

/* ------------------------------------ ADICIONAR AL FINAL DOBLE---------------*/

void adicionar_final_doble()

auxd=new(nodod); ///////// DEFINE UN NUEVO NODO ///////

cout<<"digite el valor";///SE DIGITA UN VALOR////

cin>>auxd->info;///SE LEE EL VALOR AUXD QUE APUNTA A INFO///

if (cabd==NULL) //// SI CABEERA ESTA VACIO////

cabd=auxd;///CABECERA ES IGUAL A AUXDD///

ultd=auxd;//ULTD ES IGUAL A AUXD///

cabd->ant=NULL;///CABECERA APUNTA A ANTERIOR QUE SE ENCUENTRA VACIO////

ultd->sig=NULL;///ULT APUNTA A ASIGUIENTE QUE SE ENCUENTRA VACIO////

else
 {

ultd->sig=auxd;////ULTD APUNTA A SIGUINETE QUE ES IGUAL A AUXD///

auxd->ant=ultd;///AUXD APUNTA A ANTERIOR QUE ES IGUAL A ULTD//

ultd=auxd;///ULTD ES IGUAL A AUXD//

ultd->sig=NULL;///ULTD APUNTA A SIGUIENTE QUE SE ENCUENTRA VACIO//

/* ------------------------------------ ELIMINAR AL INICIO DOBLE---------------*/

void eliminar_inicio_doble()

if(cabd==NULL)///SE COMPARA SI SIESTA VACIO///

cout<<"Lista vacia";///MOSTRAS UN MSJ LISTA VACIA///

getch();

else

if(cabd==ultd)/// SE CABECERA SI CABECERA ES IGUAL A ULTD///

{
 free(cabd);///LIBERA ESPACIO EN LA CABECERA////

cabd=NULL;/////SI CABECERA Y ULTIMO ESTAN VACIO///

ultd=NULL;

else

pd=cabd;

cabd=cabd->sig;

cout<<"Ha sido eliminado el valor:"<<pd->info;////SE MOSTRARA UN MSJ QUE A SIDI ELIMINADO EL VALOR///

free(pd);//// SE LIBERA ESPACION EN LA MEMORIA///

cabd->ant=NULL;///CABECERAAPUNTARA A ANTERIOR QUE ESTA VACIO///

getch();

/* ------------------------------------ ELIMINAR AL FINAL DOBLE---------------*/

void eliminar_final_doble()

if(cabd==NULL)///SI CABECERA ESTA VACIA////

{

cout<<"Lista vacia";

getch();

else

if(cabd==ultd)/// SE CABECERA SI CABECERA ES IGUAL A ULTD///

free(cabd);////LIBERA ESPACIO EN CABECERA///

cabd=NULL;;/////SI CABECERA Y ULTIMO ESTAN VACIO///

ultd=NULL;

else

pd=ultd->ant;///PD ES IGUAL A ULTD QUE APUNTA A ANTERIOR///

cout<<"Ha sido eliminado el valor:"<<ultd->info;

free(ultd);////LIBERA ESPACIO EN ULTD///

ultd=pd;///ULTD ES IGUAL A PD///

ultd->sig=NULL;

getch();
 }

/*------------------------------------- MOSTRAR LISTA DOBLE ------------------*/

void mostrar_lista_doble()

clrscr();

int nume=0;///SE CREA UNA NUEVA VARIABLE COMO ENTERA///

if(cabd==NULL)///SI CABECERASE SE CUENTRA VACIA//

cout<<"Lista vacia";//MOSTRAR UN MSJ CABECERA VACIA///

getch();

else

cout<<"Esta es la lista\n";///MOSTRAR UN MSJ ESTA ES LA LISTA//

pd=cabd;

while(pd!=NULL) ///UN CICLO WHILE DONDE PD SERA DIFERENTE DE VACIA //////

{
 cout<<nume<<". "<<pd->info<<"\n";

pd=pd->sig;///PD SERA IGUALA PD QUE APUNTAA SIG///

nume++;

getch();

/*------------------------------------- ADICIONAR POR VALOR DOBLE ------------------*/

void adicionar_valor_doble()

if (cabd==NULL)///SI CABECERASE SE CUENTRA VACIA//

cout<<"Lista vacia";//MOSTRAR UN MSJ CABECERA VACIA///

getch();

else

cout<<"digite el valor";////MOSTAR UN MSJ DIGITE UN VALOR///

cin>>valor;////LEER EL VALOR///
 if(valor==cabd->info)///SI VALOR SE ENCUENTRA EN CABECERA QUE APUNTA A INFO///

adicionar_inicio_doble();

else

pd=cabd;

while(pd!=NULL && pd->info!=valor) ///UN CICLO WHILE DONDE PD SERA DIFERENTE DE VACIA Y PD APUNTARA A INFO QUE DIDERENTE
O IGUAL A VALOR//////)

pd=pd->sig;//PD ES IGUAL A PD QUE APUNTA A SIG//

if(pd==NULL)///SI PD SE ENCUENTRA VACIA

cout<<"Valor no encontrado";///MOSTRA UN MSJ VALOR ENCONTRADO////

getch();

else

{
 qd=pd->ant;

auxd=new(nodod);///SE CREARA UN NUEVO NODO//

cout<<"digite la informacion";///MOSTRARA DIGITE LA INFORMACION//

cin>>auxd->info;///SE LEERA EL NUEVO NODO QUE APUNTA A INFO///

qd->sig=auxd;///QD APUNTA A SIG QUE ES IGUAL A AUXD///

auxd->ant=qd;///AUXD APUNTA A ANT QUE ES IGUAL A QD///

auxd->sig=pd;///AUXD APUNTA A SIG QUE ES IGUAL A PD///

pd->ant=auxd;///PD APUNTA A ANT QUE ES IGUAL A AUXD///

/*------------------------------------- ADICIONAR POR VALOR DOBLE ------------------*/

void adicionar_posicion_doble()

cout<<"Digite posicion";///MOSTRARA DIGITE UNA POSION///

cin>>pos; ///LEERA LA POSOCION///

if(pos==1)

{
 adicionar_inicio_doble();

else

if(cabd==NULL)///SE COMPARA SI CABECERA ESTA VACIA///

cout<<"Lista vacia";///SE MOSTRARA UN MSJ LISTA VACIA///

getch();

else

cont=0;///CONTADOR///

pd=cabd;

while(pd!=NULL)////UN CICLO WHILE DONDE PD SEA DIFERENTE O IGUAL A VACIO///

pd=pd->sig;///PDSERA IGUAL A PD QUE APUNTA A SIGUIENTE///

cont++;///CONTADOR IRA INCREMENTADO ///

if(pos==cont+1)

{
 adicionar_final_doble();

else

if(pos<1||pos>cont+1)///SI POSICION MENOR QUE 1 ENTONCES POSICION SERA MAYOR A CONTADOR///

cout<<"Posicion no valida, fuera de rango";///MOSTRARA UN MSJ POSICION NO VALIDA&///

getch();

pd=cabd;

for(i=1;i<=pos;i++)////UN CICLO FOR DONDE I ES IUAL 1 Y I MENOR O IGUAL A POSICION////

pd=pd->sig;

qd=pd->ant;

auxd=new(nodod);//// SE CREARA UN NUEVO NODO////

cout<<"Digite la informacion";////MOSTRARA DIGITE LA INFORMACIO////

cin>>auxd->info;///LEERA AUXD QUE APUNTA A INFO///

qd->sig=auxd;

auxd->ant=qd;
 auxd->sig=pd;

pd->ant=auxd;

/*------------------------------------- ELIMINAR POR VALOR DOBLE ------------------*/

void eliminar_valor_doble()

if (cabd==NULL)///SI CABECERA SE ENCUENTRA VACIA///

cout<<"Lista vacia";///MOSTRARA UN MSJ LISTA VACIA///

getch();

else

cout<<"digite el valor";///MOSTARA UN MSJ DIGITE EL VALOR///

cin>>valor;///LEERA EL VALOR///

if(valor==cabd->info)///SE COMPARA SI VALOR ES IGUAL A CABECERA QUE APUNTA A INFO///7

{

eliminar_inicio_doble();

else

pd=cabd;

while(pd!=NULL && pd->info!=valor)////UN CICLO WHILE DONDE PD SEA DIFERENTE O IGUAL A VACIO Y

//PD APUNTARA A INFO QUE ES DIFERENTE O IGUAL A VALOR///

pd=pd->sig;

if(pd==NULL)///SI PD SE ENCUENTRA VACIO//

cout<<"Valor no encontrado";///MOSTRARA UN MSJ VALOR NO ENCONTRADO///

getch();

else

qd=pd->ant;///QD ES IGUAL A PD QUE APPUNTA A ANT//

 qd->sig=pd->sig;//QD APUNTA A SIG QUE ES IGUAL A PD QUE APUNTA A SIGUIENTE///

r=pd->sig;

r->ant=qd;

cout<<"Ha sido eliminado el valor:"<<pd->info;

free(pd);///SE ELIMINARA ESPACIO EN LA MEMORIA PD///

getch();

/*------------------------------------- ELIMINAR POR VALOR DOBLE ------------------*/

void eliminar_posicion_doble()

cout<<"Digite posicion";///MOSTRARA UN MSJ DIGITE LA POSICION

cin>>pos;//LEERA LA POSICION//

if(pos==1)

eliminar_inicio_doble();

}
else

if(cabd==NULL)///SI CABECERA SE ENCUNTRA VACIO///

cout<<"Lista vacia";///MOSTRARA UN MSJ LISTA VACIA///

getch();

else

cont=0;////CONTADOR//

pd=cabd;

while(pd!=NULL)////UN CICLO WHILE DONDE PD SEA DIFERENTE O IGUAL A VACIO///

pd=pd->sig;///PD SERA IGUAL A PD QUE APUNTA A SIG///

cont++;///CONTADOR///

if(pos==cont+1)

eliminar_final_doble();

}
else

if(pos<1||pos>cont+1)

cout<<"Posicion no valida, fuera de rango";///MOSTRARA UN MSJ POSICION NO VALIDA///

getch();

pd=cabd;

for(i=1;i<=pos;i++)////UN CICLO FOR DONDE I ES IGUAL A 1 I MENOR O IGUALA POSICION///

pd=pd->sig;

qd=pd->ant;

qd->sig=pd->sig;

r=pd->sig;

r->ant=qd;

cout<<"Ha sido eliminado el valor:"<<pd->info;////MOSTRARA UN MSJ SE A ELIMINADO EL VALOR///

free(pd);///SE ELIMINARA ESPACIO EN LA MEMORIA PD///

getch();

}
 }

/************************************************MAIN*********************************************/

main ()

system("color F5");

menu();