Metodo SHAKER o Sacudida
codigo:
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
//****************************** INSERTAR ************************************//
int *Insertar(int *A ,int N)
{
for( int i = 0 ; i < N ; i++ )
{
cout<<endl<<" - Ingrese el valor ["<<i + 1<<"] = ";
cin>>A[i];
}
return A;
}
//******************************* MOSTRAR ************************************//
void Mostrar(int *A ,int N)
{
for( int i = 0 ; i < N ; i++ )
{
cout<<endl<<" - Valor ["<<i + 1<<"] = "<<A[i]<<endl;
}
}
/****************************************************************************
el método de la sacudida (shaker sort).
Es la operación de arreglar los registros de una tabla en algún orden secuencial de acuerdo a cierto criterio de orden,
con el propósito principal de facilitar las búsqueda de los miembros del conjunto ordenado.
//****************************** SHAKER o sacudida**************************************/
int *Shaker(int *A, int N)
{
int i = 0 , izq = 1 , der = N-1 , k = N-1 , aux = 0;
while( der >= izq )
{
for( i = der ; i>= izq ; i-- )
if( A[i-1] > A[i])
{
aux = A[i-1];
A[i-1]=A[i];
A[i]=aux;
k=i;
}
izq = k + 1;
for( i = izq ; i <= der ; i++)
if( A[i-1] > A[i] )
{
aux = A[i-1];
A[i-1]=A[i];
A[i]=aux;
k=i;
}
der = k-1;
}
return A;
}
int main()
{
system("COLOR F3");
int *A = NULL;
A = (int*)malloc(sizeof(int));
int N;
int opcion;
cout<<endl<<" >> INGRESE LOS VALORES : ";
cout<<endl<<" --------------------------------> ";
cin>>N;
A = Insertar( A , N );
A = Shaker( A , N );
cout<<endl<<" - [ METODO MEDIANTE SHAKER (SACUDIDA) ] - "<<endl;
Mostrar(A , N);
cout<<endl<<endl;
system("pause");
}
---------------------------------------------------------------------------------------------------------------------
Metodo Shell
codigo:
#include<iostream>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
//****************************** INSERTAR ************************************//
int *Insertar(int *A ,int N)
{
for( int i = 0 ; i < N ; i++ )
{
cout<<endl<<" - Ingrese el valor ["<<i + 1<<"] = ";
cin>>A[i];
}
return A;
}
//******************************* MOSTRAR ************************************//
void Mostrar(int *A ,int N)
{
for( int i = 0 ; i < N ; i++ )
{
cout<<endl<<" - Valor ["<<i + 1<<"] = "<<A[i]<<endl;
}
}
/****************************************************************************
El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell.
Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V.
Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso.
Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n).
Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.
//****************************** SHELL ***************************************/
int *Shell(int *A , int N)
{
int i,j,bandera,aux;
for( j = N/2 ; j > 0 ; j = j/2)
{
do
{
bandera=0;
for( i = 0 ; i < N - j ; i++)
{
if( A[i] > A[i+j] )
{
aux = A[i];
A[i] = A[i+j];
A[i+j] = aux;
bandera=1;
}
}
}
while(bandera);
}
return A;
}
int main()
{
system("COLOR F9");
int *A = NULL;
A = (int*)malloc(sizeof(int));
int N;
int opcion;
cout<<endl<<" >> INGRESE LOS VALORES : ";
cout<<endl<<" --------------------------------> ";
cin>>N;
A = Insertar( A , N );
A = Shell( A , N );
cout<<endl<<" - [ METODO MEDIANTE SHELL ] - "<<endl;
Mostrar(A , N);
cout<<endl<<endl;
system("pause");
}
---------------------------------------------------------------------------------------------------------------------
Metodo QuitShort
Codigo:
#include <algorithm> //para la función sort
#define LIM 50
using namespace std;
/****************************************************************************
El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio,
ordenar n elementos en un tiempo proporcional a n log n.
//****************************** Quitshort **************************************/
void LeerArray(int n,int x[]);
void MostrarArray(int n,int x[]);
int main()
{
int n;
int x[LIM];
cout<<" -> Ingrese el numero de elementos :";cin>>n;
LeerArray(n,x);
sort(x,x+n);//sort(array,array+numeroelementos);
cout<<"\t\t\t *** MEtodo Quic sort *** "<<endl<<endl;
cout<<"\t";MostrarArray(n,x);
system("pause>>null");
return 0;
}
void MostrarArray(int n,int x[])
{
for(int i=0;i<n;i++)
{
cout<<x[i]<<" ";
}
}
void LeerArray(int n,int x[])
{
for(int i=0;i<n;i++)
{
cout<<" Elemento ["<<i<<"]:";cin>>x[i];
}
}
