#include<iostream.h>
#include<conio.h>
class ARREGLO
 {
  public:
	void leer(float Arreglo[], int num);
	void imprimir(float arreglo[], int n);
	void imprimir2(float arreglo[], int n);
	void Leer(char arreglo[], int num);
	void Imprimir(char arreglo[], int num);
	void Imprimir2(char arreglo[], int num);
	void intercambio(float* x, float* y);
	void Intercambio(char* x, char* y);
	};

  void ARREGLO::leer(float Arreglo[], int num)
   {
    int i;
    for(i=0;i<num;i++)
    {
     cout<<"Elemento #"<<i+1<<":";
     cin>>Arreglo[i];
      }
     }

  void ARREGLO::imprimir(float arreglo[], int n)
   {
    int i;
    for(i=0;i<n;i++)
    {
     cout<<"["<<arreglo[i]<<"]";
     cout<<" ";
     }
    }

  void ARREGLO::imprimir2(float arreglo[], int n)
   {
    int i;
    for(i=(n-1);i>=0;i--)
    {
     cout<<"["<<arreglo[i]<<"]";
     cout<<" ";
     }
    }

  void ARREGLO::Leer(char arreglo[], int num)
   {
    int i;
    for(i=0;i<num;i++)
    {
     cout<<"Letra #"<<i+1<<";";
     cin>>arreglo[i];
     }
    }
  void ARREGLO::Imprimir(char arreglo[], int n)
   {
    int i;
    for(i=0;i<n;i++)
    {
     cout<<"["<<arreglo[i]<<"]";
     cout<<" ";
     }
    }

  void ARREGLO::Imprimir2(char arreglo[], int n)
   {
    int i;
    for(i=(n-1);i>=0;i--)
    {
     cout<<"["<<arreglo[i]<<"]";
     cout<<" ";
     }
    }

  void ARREGLO::intercambio(float* x,float* y)
   {
    float temp;
    temp=*x;
    *x=*y;
    *y=temp;
    }

  void ARREGLO::Intercambio(char* x, char* y)
   {
    char temp;
    temp=*x;
    *x=*y;
    *y=temp;
    }
   //****************************************
   //CLASE METODO DE ORDENAMIENTO SELECCION
   //****************************************

 class SELECCION:public ARREGLO
 {
  public:
	void seleccion(float arreglo[], int n);
	void Seleccion(char arreglo[], int n);
  };

  void SELECCION::seleccion(float arreglo[], int n)
   {
    int indice;
    int i,j;
    float elem,temp;
    for(i=0;i<n;i++)
    {
     indice=i;
     elem=arreglo[i];
     for(j=i+1;j<n;j++)
     {
      if(arreglo[j]<elem)
      {elem=arreglo[j];
       indice=j;}
       }
      temp=arreglo[i];
      arreglo[i]=arreglo[indice];
      arreglo[indice]=temp;
      }
    }

  void SELECCION::Seleccion(char arreglo[],int n)
   {
    int indice;
    int i,j;
    char elem,temp;
    for(i=0;i<n;i++)
    {
     indice=i;
     elem=arreglo[i];
     for(j=i+1;j<n;j++)
     {
      if(arreglo[j]<elem)
      {elem=arreglo[j];
       indice=j;}
      }
     temp=arreglo[i];
     arreglo[i]=arreglo[indice];
     arreglo[indice]=temp;
     }
    }
  //***********************************************
  //CLASE METODO DE ORDENAMIENTO BURBUJA
  //***********************************************

 class BURBUJA:public ARREGLO
 {
  public:
	void burbuja(float a[], int n);
	void Burbuja(char a[], int n);
	 };

  void BURBUJA::burbuja(float a[], int n)
   {
    int i,j;
    for(i=n-1;i>0;i--)
     for(j=0;j<i;j++)
      if(a[j]>a[j+1])
       intercambio(&a[j],&a[j+1]);
    }

  void BURBUJA::Burbuja(char a[], int n)
   {
    int i,j;
    for(i=n-1;i>0;i--)
     for(j=0;j<i;j++)
      if(a[j]>a[j+1])
       Intercambio(&a[j],&a[j+1]);
     }

  //****************************************
  //CLASE METODO DE ORDENAMIENTO INSERCION
  //****************************************

 class INSERCION:public ARREGLO
 {
  public:
	void insercion(float arreglo[], int n);
	void Insercion(char arreglo[], int n);

     };

  void INSERCION::insercion(float arreglo[], int n)
   {
    int i,k,x;
    for(i=0;i<n;i++)
    {
     x=arreglo[i];
     k=i-1;
     while((k>=0)&&(x<arreglo[k+1]))
     {
      intercambio(&arreglo[k],&arreglo[k+1]);
      k--;
     }
    }
   }

  void INSERCION::Insercion(char arreglo[], int n)
   {
    int i,k,x;
    for(i=0;i<n;i++)
     {
      x=arreglo[i];
      k=i-1;
      while((k>=0)&&(x<arreglo[k]))
      {
       Intercambio(&arreglo[k],&arreglo[k+1]);
       k--;
      }
     }
    }

  //******************************************
  //CLASE METODO DE ORDENAMIENTO QUICKSORT
  //******************************************

 class QUICKSORT:public ARREGLO
 {
  public:
	void quicksort(float arreglo[],float left,float right);
	void swap(float arreglo[],float i, float j);
	void Quicksort(char arreglo[],char left,char right);
	void Swap(char arreglo[],float i,float j);
   };

  void  QUICKSORT::quicksort(float arreglo[],float left,float right)
   {
    float current,last;
    if(left>=right)
      return;
    swap(arreglo,left,(left+right)/2);
    last=left;
    for(current=left+1;current<=right;current++)
     if(arreglo[current]<arreglo[left])
      swap(arreglo,++last,current);
      swap(arreglo,left,last);
      quicksort(arreglo,left,last-1);
      quicksort(arreglo,last+1,right);
     }

  void QUICKSORT::swap(float arreglo[],float i,float j)
   {
    float temp;
    temp=arreglo[i];
    arreglo[i]=arreglo[j];
    arreglo[j]=temp;
    }

  void QUICKSORT::Quicksort(char arreglo[],char left, char right)
   {
    char current,last;
    if(left>=right)
      return;
    Swap(arreglo,left,(left+right)/2);
    last=left;
    for(current=left+1;current<=right;current++)
     if(arreglo[current]<arreglo[left])
      Swap(arreglo,++last,current);
      Swap(arreglo,left,last);
      Quicksort(arreglo,left,last-1);
      Quicksort(arreglo,last+1,right);
     }

  void QUICKSORT::Swap(char arreglo[],float i,float j)
   {
    char temp;
    temp=arreglo[i];
    arreglo[i]=arreglo[j];
    arreglo[j]=temp;
    }

 //**************************************
 // CLASE METODO DE ORDENAMIENTO SHELL
 //**************************************

 class SHELL:public ARREGLO
 {
  public:
	void shell(float arreglo[],int n);
	void Shell(char arreglo[],int n);
    };

  void SHELL::shell(float arreglo[],int n)
   {
    int i,j,k,salto;
    float temp;
    salto=n/2;
    while(salto>0)
    {
     for(i=salto;i<n;i++)
     {
      j=i-salto;
      while(j>=0)
      {
       k=j+salto;
       if(arreglo[j]<=arreglo[k])
       {
	j=0;
	}
       else
       {
	temp=arreglo[j];
	arreglo[j]=arreglo[k];
	arreglo[k]=temp;
	}
       j=j-salto;
       }
      }
     salto=salto/2;
     }
    }   //fin del shell

  void SHELL::Shell(char arreglo[],int n)
   {
    int i,j,k,salto;
    char temp;
    salto=n/2;
    while(salto>0)
    {
     for(i=salto;i<n;i++)
     {
      j=i-salto;
      while(j>=0)
      {
       k=j+salto;
       if(arreglo[j]<=arreglo[k])
       {
	j=0;
	}
       else
       {
	temp=arreglo[j];
	arreglo[j]=arreglo[k];
	arreglo[k]=temp;
	}
       j=j-salto;
       }
      }
     salto=salto/2;
     }
    }   //fin del shell

 //***********************************************
 // CLASE METODO DE BUSQUEDA SECUENCIAL O LINEAL
 //***********************************************
 class SECUENCIAL:public ARREGLO
 {
  public:
	int secuencial(float arreglo[],float buscar, int n);
	int Secuencial(char arreglo[],char buscar, int n);
	};

  int SECUENCIAL::secuencial(float arreglo[],float buscar, int n)
   {
    for(int i=0;i<n;i++)
    {
    if(arreglo[i]==buscar)
     { return i+1; }
    }
    return -1;
   }

   int SECUENCIAL::Secuencial(char arreglo[],char buscar, int n)
   {
    for(int i=0;i<n;i++)
    {
    if(arreglo[i]==buscar)
     { return i+1; }
    }
    return -1;
   }

 //*************************************
 // CLASE METODO DE BUSQUEDA BINARIA
 //*************************************

 class BINARIA:public ARREGLO
 {
  public:
	int binario(float b[],float buscar,float abajo,float arriba);
	int Binario(char b[],char buscar,int abajo,int arriba);
	};
  int BINARIA::binario(float b[],float buscar,float abajo,float arriba)
   {
    int mitad;
    while(abajo<=arriba)
    {
     mitad=(abajo+arriba)/2;
     if(buscar==b[mitad])        //coicidencia
	return mitad;
     else if(buscar<b[mitad])
	arriba=mitad-1;          //busqueda en la parte baja del problema
     else
	abajo=mitad+1;           //busqueda en la parte alta del problema
	}
     return -1;                  //no se encontro
     }

  int BINARIA::Binario(char b[],char buscar,int abajo,int arriba)
   {
    int mitad;
    while(abajo<=arriba)
    {
     mitad=(abajo+arriba)/2;
     if(buscar==b[mitad])        //coicidencia
	return mitad;
     else if(buscar<b[mitad])
	arriba=mitad-1;          //busqueda en la parte baja del problema
     else
	abajo=mitad+1;           //busqueda en la parte alta del problema
	}
     return -1;                  //no se encontro
     }

 main()       //CUERPO DEL PROGRAMA
 {
  int num,orden,caso;
  int ubic,metodos;
  float Ar[100],bus;
  char opcion,busc;
  char ar[100],opc;
  SELECCION num1;
  BURBUJA num2;                //INICIALIZACION DE CLASES
  INSERCION num3;              //DE METODOS DE ORDENAMIENTO
  QUICKSORT num4;
  SHELL num5;
  SECUENCIAL num6;
  BINARIA num7;
  do{
   clrscr();
   cout<<"\t\t  ************************************\n";
   cout<<"\t\t  * PROGRAMA METODOS DE ORDENAMIENTO *\n";
   cout<<"\t\t  *      Y METODOS DE BUSQUEDA       *\n";
   cout<<"\t\t  ************************************\n\n";
   cout<<"\tTIPO DE ORDENAMIENTO:      METODOS DE BUSQUEDA:"<<endl;
   cout<<"\t 1.Seleccion                6.Busqueda secuencial o lineal"<<endl;
   cout<<"\t 2.Burbuja                  7.Busqueda binaria"<<endl;
   cout<<"\t 3.Insercion"<<endl;
   cout<<"\t 4.Quicksort"<<endl;
   cout<<"\t 5.Shell"<<endl;
   cout<<"\nOperacion que desea realizar:";
   cin>>orden;
   switch(orden)
   {
    case 1:
	clrscr();
	cout<<"\t\t  ***********************************\n";
	cout<<"\t\t  *  ORDENAMIENTO METODO SELECCION  *\n";
	cout<<"\t\t  ***********************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num1.leer(Ar,num);
	     cout<<"\nARREGLO DESORDENADO:\n";
	     num1.imprimir(Ar,num);
	     num1.seleccion(Ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num1.imprimir(Ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num1.imprimir2(Ar,num);
	     break;
	 case 2:
	     cout<<"Numero de datos a introducir: ";
	     cin>>num;
	     num1.Leer(ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num1.Imprimir(ar,num);
	     num1.Seleccion(ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num1.Imprimir(ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num1.Imprimir2(ar,num);
	     break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
	    }
	   break;
    case 2:
	clrscr();
	cout<<"\t\t  *******************************\n";
	cout<<"\t\t  *  ORDENACION METODO BURBUJA  *\n";
	cout<<"\t\t  *******************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num2.leer(Ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num2.imprimir(Ar,num);
	     num2.burbuja(Ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num2.imprimir(Ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num2.imprimir2(Ar,num);
	     break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num2.Leer(ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num2.Imprimir(ar,num);
	     num2.Burbuja(ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num2.Imprimir(ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num2.Imprimir2(ar,num);
	     break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
	    }
	   break;
    case 3:
	clrscr();
	cout<<"\t\t  *********************************\n";
	cout<<"\t\t  *  ORDENACION METODO INSERCION  *\n";
	cout<<"\t\t  *********************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num3.leer(Ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num3.imprimir(Ar,num);
	     num3.insercion(Ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num3.imprimir(Ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num3.imprimir2(Ar,num);
	     break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num3.Leer(ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num3.Imprimir(ar,num);
	     num3.Insercion(ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num3.Imprimir(ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num3.Imprimir2(ar,num);
	     break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
	    }
	   break;
    case 4:
	clrscr();
	cout<<"\t\t  *********************************\n";
	cout<<"\t\t  *  ORDENACION METODO QUICKSORT  *\n";
	cout<<"\t\t  *********************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num4.leer(Ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num4.imprimir(Ar,num);
	     num4.quicksort(Ar,0,num-1);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num4.imprimir(Ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num4.imprimir2(Ar,num);
	     break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num4.Leer(ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num4.Imprimir(ar,num);
	     num4.Quicksort(ar,0,num-1);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num4.Imprimir(ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num4.Imprimir2(ar,num);
	     break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
	    }
	   break;
    case 5:
	clrscr();
	cout<<"\t\t  *****************************\n";
	cout<<"\t\t  *  ORDENACION METODO SHELL  *\n";
	cout<<"\t\t  *****************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num5.leer(Ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num5.imprimir(Ar,num);
	     num5.shell(Ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num5.imprimir(Ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num5.imprimir2(Ar,num);
	     break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num5.Leer(ar,num);
	     cout<<"\nARREGLO DESORDENADO: \n";
	     num5.Imprimir(ar,num);
	     num5.Shell(ar,num);
	     cout<<"\n\nORDENACION ASCENDENTE: \n";
	     num5.Imprimir(ar,num);
	     cout<<"\n\nORDENACION DESCENDENTE: \n";
	     num5.Imprimir2(ar,num);
	     break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
	    }
	   break;
    case 6:
	clrscr();
	cout<<"\t\t  **********************************\n";
	cout<<"\t\t  *  BUSQUEDA SECUENCIAL O LINEAL  *\n";
	cout<<"\t\t  **********************************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num6.leer(Ar,num);
	     cout<<"\nMetodos para ordenar el arreglo"<<endl;
	     cout<<"1.-Seleccion"<<endl;
	     cout<<"2.-Insercion"<<endl;
	     cout<<"3.-Burbuja"<<endl;
	     cout<<"4.-Quicksort"<<endl;
	     cout<<"5.-Shell"<<endl;
	     cout<<"\nOpcion deseada:";
	     cin>>metodos;
	     switch(metodos)
	     {
	      case 1:
		  num1.seleccion(Ar,num);
		  break;
	      case 2:
		  num3.insercion(Ar,num);
		  break;
	      case 3:
		  num2.burbuja(Ar,num);
		  break;
	      case 4:
		  num4.quicksort(Ar,0,num-1);
		  break;
	      case 5:
		  num5.shell(Ar,num);
		  break;
	      default:
		     cout<<"Opcion no valida"<<endl;
		     break;
	      }
	      cout<<"\nORDENACION DESCENDENTE: \n";
	      num6.imprimir2(Ar,num);
	      cout<<"\n\nORDENACION ASCENDENTE: \n";
	      num6.imprimir(Ar,num);
	      cout<<"\nNumero que desea buscar: ";
	      cin>>bus;
	      ubic=(num6.secuencial(Ar,bus,num));
	      if(ubic!=-1)
		cout<<bus<<"se encontro el valor en la posicion["<<ubic<<"]"<<"del arreglo"<<endl;
	      else
		{ cout<<"Valor no encontrado"<<endl; }
	      break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num6.Leer(ar,num);
	     cout<<"\nMetodos para ordenar el arreglo"<<endl;
	     cout<<"1.-Seleccion"<<endl;
	     cout<<"2.-Insercion"<<endl;
	     cout<<"3.-Burbuja"<<endl;
	     cout<<"4.-Quicksort"<<endl;
	     cout<<"5.-Shell"<<endl;
	     cout<<"\nOpcion deseada:";
	     cin>>metodos;
	     switch(metodos)
	     {
	      case 1:
		  num1.Seleccion(ar,num);
		  break;
	      case 2:
		  num3.Insercion(ar,num);
		  break;
	      case 3:
		  num2.Burbuja(ar,num);
		  break;
	      case 4:
		  num4.Quicksort(ar,0,num-1);
		  break;
	      case 5:
		  num5.Shell(ar,num);
		  break;
	      default:
		     cout<<"Opcion no valida"<<endl;
		     break;
	      }
	      cout<<"\nORDENACION DESCENDENTE: \n";
	      num6.Imprimir2(ar,num);
	      cout<<"\n\nORDENACION ASCENDENTE: \n";
	      num6.Imprimir(ar,num);
	      cout<<"\nNumero que desea buscar: ";
	      cin>>busc;
	      ubic=(num6.Secuencial(ar,busc,num));
	      if(ubic!=-1)
		cout<<busc<<"se encontro el valor en la posicion["<<ubic<<"]"<<"del arreglo"<<endl;
	      else
		{ cout<<"Valor no encontrado"<<endl; }
	      break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
		}
	     break;
    case 7:

		clrscr();
	cout<<"\t\t  **********************\n";
	cout<<"\t\t  *  BUSQUEDA BINARIA  *\n";
	cout<<"\t\t  **********************\n\n";
	cout<<"Tipo de dato:\n\t\t1.-Numerico\t\t\t2.-Caracter\n";
	cin>>caso;
	switch(caso)
	{
	 case 1:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num7.leer(Ar,num);
	     cout<<"\nMetodos para ordenar el arreglo"<<endl;
	     cout<<"1.-Seleccion"<<endl;
	     cout<<"2.-Insercion"<<endl;
	     cout<<"3.-Burbuja"<<endl;
	     cout<<"4.-Quicksort"<<endl;
	     cout<<"5.-Shell"<<endl;
	     cout<<"\nOpcion deseada:";
	     cin>>metodos;
	     switch(metodos)
	     {
	      case 1:
		  num1.seleccion(Ar,num);
		  break;
	      case 2:
		  num3.insercion(Ar,num);
		  break;
	      case 3:
		  num2.burbuja(Ar,num);
		  break;
	      case 4:
		  num4.quicksort(Ar,0,num-1);
		  break;
	      case 5:
		  num5.shell(Ar,num);
		  break;
	      default:
		     cout<<"Opcion no valida"<<endl;
		     break;
	      }
	      cout<<"\nORDENACION DESCENDENTE: \n";
	      num7.imprimir2(Ar,num);
	      cout<<"\n\nORDENACION ASCENDENTE: \n";
	      num7.imprimir(Ar,num);
	      cout<<"\nNumero que desea buscar: ";
	      cin>>bus;
	      ubic=(num7.binario(Ar,bus,0,num-1));
	      if(ubic!=-1)
		cout<<bus<<"se encontro el valor en la posicion["<<ubic+1<<"]"<<"del arreglo"<<endl;
	      else
		{ cout<<"Valor no encontrado"<<endl; }
	      break;
	 case 2:
	     cout<<"Numero de datos a introducir:";
	     cin>>num;
	     num6.Leer(ar,num);
	     cout<<"\nMetodos para ordenar el arreglo"<<endl;
	     cout<<"1.-Seleccion"<<endl;
	     cout<<"2.-Insercion"<<endl;
	     cout<<"3.-Burbuja"<<endl;
	     cout<<"4.-Quicksort"<<endl;
	     cout<<"5.-Shell"<<endl;
	     cout<<"\nOpcion deseada:";
	     cin>>metodos;
	     switch(metodos)
	     {
	      case 1:
		  num1.Seleccion(ar,num);
		  break;
	      case 2:
		  num3.Insercion(ar,num);
		  break;
	      case 3:
		  num2.Burbuja(ar,num);
		  break;
	      case 4:
		  num4.Quicksort(ar,0,num-1);
		  break;
	      case 5:
		  num5.Shell(ar,num);
		  break;
	      default:
		     cout<<"Opcion no valida"<<endl;
		     break;
	      }
	      cout<<"\nORDENACION DESCENDENTE: \n";
	      num7.Imprimir2(ar,num);
	      cout<<"\n\nORDENACION ASCENDENTE: \n";
	      num7.Imprimir(ar,num);
	      cout<<"\nNumero que desea buscar: ";
	      cin>>busc;
	      ubic=(num7.Binario(ar,busc,0,num-1));
	      if(ubic!=-1)
		cout<<busc<<"se encontro el valor en la posicion["<<ubic+1<<"]"<<"del arreglo"<<endl;
	      else
		{ cout<<"Valor no encontrado"<<endl; }
	      break;
	 default:
		cout<<"\nOpcion no valida\n";
		break;
		}
	     break;

	 default:
	 break;
	 }
	 cout<<"\n\nDesea realizar otra operacion (s/n) :";
	 cin>>opc;
	 }while(opc=='s');
	 cout<<"\n\t\t\t Presione una tecla para continuar"<<endl;
	 getch();
	 return 0;
	 }