Ordenar completo
#includelt;fstreamgt;
#includelt;iostreamgt;
#includelt;cstdlibgt; //Funciones de uso común
#includelt; windows.hgt;
#includelt;time.hgt;
#includelt;iomanipgt;//formato de salida
usando el espacio de nombres std ;
int compare[7], change[7], move[7]; //comparar matriz es el número de comparaciones, cambiar matriz es el número de intercambios y mover matriz es el número de movimientos
clase SortableSList
{
public:
SortableSList()
void Reload(); /Función de datos iniciales
void Save_File(); //Guardar información
void InsertSort(); //Clasificación por inserción directa
void SelectSort(); /Clasificación por selección simple
void BubbleSort(); //Clasificación de burbujas
void QuickSort(); //Clasificación rápida
void ShellSort(); Hill Sort
void HeapSort(); //Heap Sort
void MergeSort(); //clasificación por fusión bidireccional
void QuickSort(int left, int derecha);
void PrintBeforeSort();
void PrintAfterSort()
privado:
int Partición(int izquierda, int derecha);
void InsSort(int h);
void Merge(int izquierda, int mid, int derecha
void Min(int i)
int *l
int n;
int *randarray
};
SortableSList :: SortableSList()
{
coutlt;lt;".
| Ingrese el número de dígitos n que se ordenarán: ";
cingt;gt;n; // Ingrese el número de números aleatorios que se generarán
coutlt;lt;" || "lt;lt;endl;
coutlt;lt;"| ---------------------- --- ----------------------------------------------- ---|"lt; lt;endl;
coutlt;lt;"||"lt;lt;endl;
coutlt;lt;"| Por favor, espere... |"lt ; lt; endl;
l=nuevo int[n];
randarray=nuevo int[n];
for(int i= 0; ilt ;n;i) //Generar aleatoriamente números del 1 al 10000
l[i]=randarray[i] =rand()10000;
}
void SortableSList::InsertSort()
{
int i, j
for(i=1; ilt; n; i ) {
int x=l[i];
mover[0]
for(j=i -1;jgt;=0amp;amp; xlt; l[j]; j--)
{
comparar[0];
l[j 1]=l[j], cambiar [0] ;
mover[0]
}
comparar[0]
l[j 1]=x ;
}
}
/~~~~~~~~~~~~~~~ Clasificación por selección simple~~~~~~~ ~~ ~~~~~~~~~~~~
void Swap(intamp; a, intamp.b)
{
int e= a; a=b; b=e;
}
{
s=i; /p >
for(int j=i 1;jlt;n;j)
if(l[j]lt;l[s]) s=j;
Intercambiar (l[i], l[s]), mover[1]= mover[1] 3, cambiar[1]
}
}
;//~~~~~~~~~~~~~~~ Clasificación rápida~~~~~~~~~~~~~~~~~~~~~~~~~~
int SortableSList::Partition(int izquierda, int derecha)
{
int i=izquierda, j=derecha 1;
hacer {
hacer
{i; comparar[3];}mientras(l[i]lt; l[izquierda]
hacer
>{j--; comparar[3];}mientras(l[j]gt; l[izquierda]);
if(ilt;
j) Intercambiar(l[i], l[j]), cambiar[3];
}mientras(ilt; j
Intercambiar(l[izquierda], l); [j]), mover[3]=mover[3] 3, cambiar[3];
devolver
}
void SortableSList:: QuickSort(int izquierda, int derecha)
{
if(leftlt;derecha)
{
int j=Partición(izquierda , derecha);
QuickSort(izquierda, j-1);
QuickSort(j 1, derecha
}
}
void SortableSList::QuickSort()
{
QuickSort(0, n-1
}
//****************** Clasificación de colinas **********************
void SortableSList::InsSort(int h)
{
int i, j
int x; > for(i=h; ilt; n; i =h){
x=l[i];
mover[4]; [4] ;
cambiar[4]
for(j=i-h;jgt;=0 amp;amp; xlt;l[j];j-=h)
{
comparar[4];
l[j h]=l[j]
cambiar[4]; p>
p>
mover[4]
}
l[j h]=x
mover[4] ; /p>
}
}
}
}
void SortableSList: .ShellSort()
{
int incr=n, i
hacer{
incr=incr/3
for(i; =0; ilt; incr; i ) InsSort(incr);
}mientras(incr gt; 1); ~~~~~ ~~~~~~~~~~ Ordenación de burbujas ~~~~~~~~~~~~~~~~~~~~
void SortableSList::BubbleSort( )
{
int i=n-1, k =1, j, último
while(igt; 0){
último=0 ;
for(j=0;jlt;i;j)
{
comparar[2] ;
if(l [j 1]lt; l[j])
{
Intercambiar(l[j], l[j 1]);
último=j ;
}
movimiento[2]=movimiento[2]
3;
}
cambio[2]
i= último
}
}
//~~~~~~~~~~~~~~~~~~~ Ordenación del montón~~~~~~~~~~~~~~~~~~
void SortableSList::Min(int i){
int m = i
int s = lt 1; t = (ilt;lt;1) 1;
if(tgt;=n){
comparar[5]; >
}
if(l[s]lt; l[m]){
m =
comparar[5] ;
cambiar[5];
}
if(l[t]lt; l[m]){
m = t ;
comparar[5] ;
cambiar[5] ;
cambiar[5] ;
}
if(m!=i)
{
mover[5];
intercambiar(l[m], l[i]);
Min(m);
}
}
void SortableSList: .HeapSort(){
para (int i=(ngt; gt; 1)-1; igt; = 0; i--){
Min
}
/~~~~~~~~~~~~~~~~~~~ Clasificación por combinación bidireccional~~~~~~~~~~~ ~~~~~ ~~
void SortableSList::MergeSort()
{
int left, right, mid, size=1 //El tamaño de la variable es el tamaño; de la subsecuencia, el valor inicial es 1
while(sizelt;n)
{
left=0;
while( tamaño izquierdolt;n)
{
mid=tamaño izquierdo-1
if(tamaño mediogt; n-1)right=n-1; /p>
else derecha = tamaño medio;
Fusionar(izquierda, media, derecha
izquierda=derecha
}
size*=2; //El tamaño se multiplica por 2 al final de cada clasificación
}
}
{
int i, j;
for(i=0; ilt; 7; i )//seis bucles de clasificación
{ comparar[i]=cambiar[i ]=move[i]=0 ;}
long int gasto[7];
int range[7]; //clasificación
long int t1 , t2, t3, t4, t5 , t6, t7, t8, t9, t10, t11, t12, t13, t14; //hora de inicio, que es la hora actual
int se
lect;
bool a=true;
coutlt;lt;" *----------------------- -------------------------------------------------- ---*"lt;lt;endl;
coutlt;lt;"| Comparación de rendimiento de varios algoritmos de secuenciación interna Comparación de rendimiento de varios algoritmos de secuenciación interna|"lt;lt;endl;
p>coutlt;lt;"|------------------------------------------ -------------------------------|"lt;lt. endl;
coutlt;lt;"||"lt;lt;endl;
coutlt;lt;"| 1 - Generar una lista de objetivos para comparar varios algoritmos de clasificación internos |"lt;lt;endl;
p>coutlt;lt;"| "lt;lt;endl;
coutlt;lt;".| "lt;lt;endl;.
//coutlt;lt;"
3-Imprime la matriz antes de la matriz.| 3-Imprime los datos antes y después de ordenar la matriz|"lt;lt;endl ;
//coutlt;lt;"
//coutlt;lt;". |"lt;lt;endl;
//coutlt;lt;".
2 - Salir del sistema||"lt;lt.||"lt;lt; endl;
coutlt;lt;"|---------------- ------------------------------------------------- - - --------|"lt;lt;endl;
hacer{
coutlt;lt;"|"lt;lt;endl;
coutlt;lt;"|"lt;lt;endl;
coutlt;lt;"|Por favor escriba la operación que desea seleccionar:";
cingt; gt; seleccionar;
coutlt; "Recargar();
t11=GetTickCount();
d.HeapSort();
t12=GetTickCount();
d.Reload();<
t13=GetTickCount();
d.MergeSort();
t14=GetTickCount();
d.MergeSort();
d.MergeSort()MergeSort()
t14= GetTickCount();
Tiempo invertido[0]=t2-t1;
Tiempo invertido[1]=t4-t3;
Tiempo invertido[2] =t6-t5;
Dedicar tiempo[3]=t8-t7;
Dedicar tiempo[4]=t10-t9;
Dedicar tiempo[5] =t12-t11;
gasto[6]=t14-t13;
for(i=0;ilt;7;i)//clasificación basada en el tiempo de gasto
{
int t=1
for(j=0; jlt; 7; j )
{
if(i!=j)
if(pasar tiempo[i] gt; gastar tiempo[j]) t;
}
rango[i]=t ;
}
coutlt;lt;"||"lt;lt;endl;
coutlt;lt;"| Tiempo total invertido**** Tiempo necesario: aprox."lt;lt; setw(5)lt;lt;sendtime[0] sendtime[1] sendtime[2] sendtime[3] sendtime[4]lt;lt; "ms |"lt;lt; lt; "ms |" lt; lt; -------------------------------------------------- -|"lt;lt;endl;
coutlt;lt;"| --- Los resultados son los siguientes--- |"lt;lt.endl;
coutlt; lt;" |---------------------------------------------- --- --------------------|"es;es;
endl;
cout lt;lt;"lt;lt;lt;lt;lt;lt;lt;lt;lt;| tiempo(m) "|Tiempo(ms)"lt;lt;" |Ranking de tiempo"lt;lt;setw(3)lt;lt;"|Complejidad de tiempo|"lt;lt; endl;
coutlt;lt;"|--------- - --------- ---------- -------- -- ---------- ---------- -----------|"lt;lt;endl;
coutlt;lt;"| Ordenación por inserción |"lt;lt;setw(8)lt;lt;compare[ 0]lt;lt;".
|"lt;lt;setw(8)lt;lt;cambiar[0]lt;lt;"| "lt;lt;setw(9)lt;lt;mover[0]lt;lt;"| lt;setw(8)lt;lt;Tómese el tiempo[0]lt;lt;"| "lt;"setw(8)lt;lt;range[0]lt;lt;" | "lt;lt;.| "lt;lt;setw(11)lt;lt;" n*n |"lt;lt;endl;
coutlt;lt;"|---------- -- -------|---------- ---------- ---------- ---------- -- -------- -----------|"lt;lt;endl;
coutlt;lt;lt;"| seleccione ordenar |"lt;lt; setw(8)lt;lt;comparar[1]lt;lt;"|" lt;lt;setw(8)lt;lt;cambiar[1]lt;lt;"|"|" lt;lt;setw( 9)lt;lt;mover[1]lt;lt;"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"| "| "|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"|"lt;lt;setw(8)lt ;lt ;range[1]lt;lt;"|"lt;lt;sew(11)lt;lt;" n*n |"lt;lt;endl;
coutlt;lt;" |- --------- ---------|--- ------- ---------- --------- - - --------- -----------|"lt;lt;endl;
coutlt;lt; lt;"| clasificación burbujeante |"lt ;lt ;setw(8)lt;lt;comparar[2]lt;lt;"|"lt;lt;setw(8)lt;lt;cambiar[2]lt;lt;"|"lt;lt;setw (9 )lt;lt;mover[2]lt;lt;"|"lt;lt;setw(8)lt;lt;tomar tiempo[2]lt;lt;"|"lt;lt;setw(8) lt; lt;range[2]lt;lt;"|"lt;lt;setw(11)lt;lt;" n*n |"lt;lt;lt;endl;
coutlt; "|---------- ----- ----|---------- ---------- ------ -- -- ---------- -----------|"lt;lt;endl;
coutlt;lt;"| clasificación rápida |" lt; lt;setw(8)lt;lt;comparar[3]lt;lt;".
|"lt;lt;setw(8)lt;lt;cambiar[3]lt;lt;"| "lt;lt;setw(9)lt;lt;mover[3]lt;lt;"| lt;setw(8)lt;lt Tiempo invertido[3]lt;lt;"|"lt;lt;setw(8)lt;lt;Rango[3]lt;lt;"|"lt;lt;setw. (11)lt;lt;" n*log2n |"lt;lt;endl;
coutlt;lt;" |---------- -------- -|---------- ---------- ---------- ---------- -------- -- -----------|"lt;lt;endl;
coutlt;lt;"| Clasificación de colinas |"lt;lt; >>p>
coutlt;lt;"|---------- ---------|---------- ---------- ---- ------ ---------- -----------|"lt;lt;endl;
coutlt;lt;"| Clasificación del montón |"lt;lt;setw(8)lt;lt;comparar[5]lt;lt;"|"lt;lt;setw(8)lt;lt;cambiar[5]lt;lt;"|"lt; lt;setw(9)lt;lt;Mover[5]lt;lt.|"lt;lt;setw(8)lt;lt;Tómate tiempo[5]lt;lt;"|"lt;lt;setw( 8)lt;lt;range[5]lt;lt;"|"lt;lt;sew(11)lt;lt;" n*log2n |"lt;lt;lt;endl;
coutlt;lt;" *-------------------------------------------- ------ --------------------------------*"lt;lt;endl;
coutlt;lt ;"| Combinar clasificación|"lt;lt;setw(8)lt;lt;Compare[6]lt;lt;"|"lt;lt;setw(8)lt;lt;cambiar[ 6]lt;lt; "|"lt;lt;setw(9)lt;lt mover[6]lt;lt;"|"lt;lt;setw(8)lt;lt. ;lt;"|" lt;lt;setw(8)lt;lt;rango[6]lt;lt;|"|"lt;lt;setw(11)lt;lt; " n*log2n |"lt; lt;endl;
coutlt;lt;" *--------------------------------- ------ -------------------------------------*"lt;lt; endl
a=true;
coutlt;lt;"/nSi se imprimen las colas de clasificación previa y posterior (seleccione 1 para imprimir o seleccione 2 para regresar)\n" ;
int sel;
cingt;gt;sel;
if(sel==1){
d.PrintBeforeSort( );
>
d.PrintAfterSort();
}
else if(sel==2){
continuar;
}
else if(select= =2)
{
coutlt;lt;" *------------- -------------------------------------------------- -------------*"lt;lt;endl;
coutlt;lt;"| ---Fin del programa--- |"lt;lt;endl ;
coutlt;lt;" *------------------------------------ ---- ---------------------------------- ------*"lt;lt; endl;
a=false;
}
else
{
coutlt;lt;"| Su entrada es incorrecta, vuelva a ingresar |"lt;lt;endl;
coutlt;lt;"|"lt;lt;endl;
a=true;
}
}mientras(a==true);
devuelve 0;
}