clasificación + búsqueda binaria
1. Merge sort El núcleo de merge
sort fusiona dos matrices ordenadas,
comienza sum [] len, divide el intervalo grande en múltiples intervalos pequeños, cuando begin>=end termina, llama a la función recursiva,
divide la matriz original en intervalos uno por uno,
y luego ejecuta la operación de combinación. El
espacio inicial de la matriz es 2
combinación (num [], comienzo final)
{ dividido en dos intervalos , debe solicitar un espacio temporal, comparar el tamaño de los dos intervalos, colocar el resultado de la comparación en el espacio de matriz temporal solicitado cuando finaliza la comparación Luego copie el contenido del espacio de matriz temporal solicitado a la matriz original (coloque en un bucle) num[begin+i]=tmp[i]; finalmente libere el espacio de matriz temporal } 2 . Clasificación de burbuja Clasificación de burbuja El ciclo de dos capas compara arr[j] y arr[j+1] y compara dos adyacentes 3. Clasificación de selección Seleccione la más pequeña en cada ronda de clasificación de selección y luego intercambie arr[min] y arr[i ] 4. Clasificación por inserción Clasificación por inserción De forma predeterminada, se ordena el primer elemento. Inserte la matriz no ordenada en la matriz ordenada a su vez. Inserte la matriz ordenada hacia atrás. 5. Búsqueda binaria (se registra la complejidad de tiempo de la matriz ordenada) 6. Ordenación rápida ( divide y vencerás recursivo) búsqueda de clasificación rápida El valor estándar será más pequeño que el valor estándar a la izquierda, y el más grande que el valor estándar se colocará a la derecha, y luego repita la operación en los lados izquierdo y derecho (excavando y método de llenado) (método de división intercelular) 7. Clasificación de montones
La clasificación del montón se basa en la idea de un árbol binario completo izquierda 2 i+1 derecha 2 i+2 0–n/2-1
primero cree el montón inicial
y luego coloque la parte superior del montón de intercambio al final o en el frente (montón grande y montón pequeño)
para ajustar el montón
Complejidad temporal del algoritmo de ordenación Complejidad
1. Ordenación por fusión
#include<stdio.h>
#include<stdlib.h>
int res=0;
void merge(int num[],int begin,int end)
{
int begin1=begin;
int end1=begin+(end-begin)/2;
int begin2=end1+1;
int end2=end;
int*temp=(int*)malloc(sizeof(int)*(end-begin+1));
int i=0;
while(begin1<=end1&&begin2<=end2)
{
if(num[begin1]<=num[begin2])
{
temp[i]=num[begin1];
i++;
begin1++;
}
else
{
temp[i]=num[begin2];
i++;
begin2++;
res=res+end1-begin1+1;
}
}
while(begin1<=end1)
{
temp[i]=num[begin1];
i++;
begin1++;
}
while(begin2<=end2)
{
temp[i]=num[begin2];
i++;
begin2++;
}
//copy num
for(int i=0;i<(end-begin)+1;i++)
{
num[begin+i]=temp[i];
}
// del
free(temp);
temp=NULL;
}
void mergesort(int num[],int nbegin,int nend)
{
if(num==NULL||nbegin>=nend) return;
int mid=nbegin+(nend-nbegin)/2;
mergesort(num,nbegin,mid);
mergesort(num,mid+1,nend);
merge(num,nbegin,nend);
}
int main()
{
int num[10]={
10,2,5,13,24,31,23,6,7,58};
mergesort(num,0,sizeof(num)/sizeof(int)-1);
for(int i=0;i<10;i++)
{
printf("%d\n",num[i]);
}
printf("%d\n",res);
return 0;
}
2. Clasificación de burbujas
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 void bubblesort(int *num,int len)
5 {
6 int flag=0;
7 if(num==NULL||len<=1) return ;
8 for(int i=0;i<len-1;i++)
9 {
10 flag=0;
11 for(int j=0;j<len-1;j++)
12 {
13 if(num[j]>num[j+1])
14 {
15 num[j]=num[j]^num[j+1];
16 num[j+1]=num[j]^num[j+1];
17 num[j]=num[j]^num[j+1];
18 flag=1;
19 }
20 }
21
22 if(flag==0) break;
23 }
24
25 }
26
27 int main()
28 {
29 int num[10]={
10,2,5,13,24,31,23,6,7,58};
30
31 bubblesort(num,sizeof(num)/sizeof(num[0]));
32
33 for(int i=0;i<10;i++)
34 {
35 printf("%d\n",num[i]);
36 }
37 return 0;
38 }
3. Clasificación de selección
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 void selectsort(int *num,int len)
5 {
6 int min;
7 int i;
8 int j;
9 for(i=0;i<len-1;i++)
10 {
11 min=i;
12 for(j=i+1;j<len;j++)
13 {
14 if(num[min]>num[j])
15 {
16 min=j;
17 }
18
19 }
20 if(min!=i)
21 {
22 num[min]=num[i]^num[min];
23 num[i]=num[i]^num[min];
24 num[min]=num[i]^num[min];
25 }
26 }
27 }
28
29 int main()
30 {
31 int num[10]={
10,2,5,13,24,31,23,6,7,58};
32
33 selectsort(num,sizeof(num)/sizeof(num[0]));
34
35 for(int i=0;i<10;i++)
36 {
37 printf("%d\n",num[i]);
38 }
39 return 0;
40 }
4. Clasificación por inserción
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 void insertsort(int *num,int len)
5 {
6 int j=0;
7
8 for(int i=1;i<len;i++)
9 {
10 j=i-1;
11 int temp=num[i];
12 while(temp<num[j]&&j>=0)
13 {
14 num[j+1]=num[j];
15 j--;
16 }
17 num[j+1]=temp;
18
19 }
20
22 }
23
24 int main()
25 {
26 int num[10]={
10,2,5,13,24,31,23,6,7,58};
27
28 insertsort(num,sizeof(num)/sizeof(num[0]));
29
30 for(int i=0;i<10;i++)
31 {
32 printf("%d\n",num[i]);
33 }
34 return 0;
35 }
5. Búsqueda binaria
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int binarychop(int *arr,int len,int n)
5 {
6 int begin=0;
7 int end=len-1;
8 int mid=begin+(end-begin)/2;
9 while(begin<=end)
10 {
11 if(arr[mid]>n)
12 end=mid-1;
13 else if(arr[mid]<n)
14 begin=mid+1;
15 else
16 return mid;
17
18 mid=begin+(end-begin)/2;
19 }
20
21 return-1;
22
23 }
24
25 int main()
26 {
27 int num[10]={
1,2,3,4,5,6,7,8,9,10};
28
29 int a=binarychop(num,sizeof(num)/sizeof(num[0]),6);
30 printf("%d\n",a);
31 for(int i=0;i<10;i++)
32 {
33 printf("%d\n",num[i]);
34 }
35 return 0;
36 }
6. Remo rápido
1 #include<stdio.h>
2 #include<stdlib.h>
3 //挖坑填補法
4 int sort2(int *arr,int begin,int end);
5 int sort(int *arr,int begin,int end)
6 {
7 int temp=arr[begin];
8 while(begin<end)
9 {
10 while(begin<end)
11 {
12 if(arr[end]<temp)
13 {
14 arr[begin]=arr[end];
15 begin++;
16 break;
17 }
18 end--;
19 }
20 while(begin<end)
21 {
22 if(arr[begin]>temp)
23 {
24 arr[end]=arr[begin];
25 end--;
26 break;
27 }
28 begin++;
29 }
30 }
31 arr[begin]=temp;
32 return begin;
33
34 }
35 void quicksort(int *arr,int begin,int end)
36 {
37 if(arr==NULL||begin>=end)return ;
38
39 //找標準值
40 int srtand=sort2(arr,begin,end);
41 quicksort(arr,begin,srtand-1);
42 quicksort(arr,srtand+1,end);
43 }
44 //區間分割法 小區間擴張法
45 int sort2(int *arr,int begin,int end)
int small=begin-1;
48 for(begin;begin<end;begin++)
49 {
50 if(arr[begin]<arr[end])
51 {
52
53 if(++small!=begin)
54 {
55 arr[small]=arr[small]^arr[begin];
56 arr[begin]=arr[small]^arr[begin];
57 arr[small]=arr[small]^arr[begin];
58
59 }
60
61 }
62
63 }
64 if(++small!=end)
65 {
66 arr[small]=arr[small]^arr[end];
67 arr[end]=arr[small]^arr[end];
68 arr[small]=arr[small]^arr[end];
69 }
70 return small;
7. Ordenar montones
1 #include<stdio.h>
2 #include<stdlib.h>
3 //0 --n-1 左孩子 2i+1 右孩子 2i+2 父親 0--n/2-1 大堆 父親是三個裏面的最大值 小堆 父親是三者裏面的最小值 是一顆完全的二茶樹
4 // 初始堆 調整父親節點 sort交換堆頂
5 #define LEFT 2*rootID+1
6 #define RIGHT 2*rootID+2
7 void adjust(int *arr ,int len ,int rootID)
8 {
9 //兩個孩子
10 while(1)
11 {
12 if(RIGHT<len)
13 {
14 if(arr[LEFT]<arr[RIGHT])
15 {
16 if(arr[RIGHT]>arr[rootID])
17 {
18 arr[RIGHT]=arr[RIGHT]^arr[rootID];
19 arr[rootID]=arr[RIGHT]^arr[rootID];
20 arr[RIGHT]=arr[RIGHT]^arr[rootID];
21 rootID=RIGHT;
22 continue;
23 }
24 else
25 {
26 break;
27 }
28 }
29 else
30 {
31 if(arr[LEFT]>arr[rootID])
32 {
33 arr[LEFT]=arr[LEFT]^arr[rootID];
34 arr[rootID]=arr[LEFT]^arr[rootID];
35 arr[LEFT]=arr[LEFT]^arr[rootID];
36 rootID=LEFT;
37 continue;
38 }
39 else
40 {
41 break;
42 }
43 }
45 }
else if(LEFT<len)
47 {
48 if(arr[LEFT]>arr[rootID])
49 {
50 arr[LEFT]=arr[LEFT]^arr[rootID];
51 arr[rootID]=arr[LEFT]^arr[rootID];
52 arr[LEFT]=arr[LEFT]^arr[rootID];
53 rootID=LEFT;
54 continue;
55 }
56 else
57 {
58 break;
59
60 }
61 }
62 else
63 {
64 break;
65 }
66 }
67
68 }
69
70
71 void heapsort(int* arr,int len)
72 {
73
74 if(arr==NULL||len<=0) return ;
75 //構建初始堆
76 int n=len/2-1;
77 for(n;n>=0;n--)
78 {
79 // 調整各個堆頂
80 adjust(arr,len,n);
81 }
82 //交換
83
84 for(int i=len-1;i>0;i--)
85 {
86 arr[0]=arr[0]^arr[i];
87 arr[i]=arr[0]^arr[i];
88 arr[0]=arr[0]^arr[i];
89 adjust(arr,i,0);
90 }
91 }
92
93 int main()
94 {
95 int num[10]={
1,2,3,4,7,6,7,8,9,10};
96
97 heapsort(num,sizeof(num)/sizeof(num[0]));
98 for(int i=0;i<10;i++)
99 {
100 printf("%d\n",num[i]);
101 }
102 return 0;
103 }