冒泡排序
首先遍历数组,对相邻两个元素进行比较,让小的排在前面,大的排在后面,每遍历完一次,就可以得到无序数中最大的一个数,且这个数就排在了正确的位置上(最后)。再对剩下的无序数进行遍历,经过n次后,整个数组就完全有序了。
平均时间复杂度
O
(
n
2
)
O(n^2)
O(n2) 、最坏时间复杂度
O
(
n
2
)
O(n^2)
O(n2),最好时间复杂度
O
(
n
)
O(n)
O(n),空间复杂度
O
(
1
)
O(1)
O(1),稳定。
void bubbleSort(int a[]){
int len=sizeof(a)/sizeof(a[0]);
int tmp=0;
for(int i=0;i<len-1;i++){
for(int j=0;j<len-i-1;j++){
if(a[j]>a[j+1]){
tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
return;
}
改进:假设还没进行完上述程序,但数组左边的数字有序了,就不用再比较了,然而该程序还会继续比较。因此,可以设置一个变量,记录每一轮比较是否有交换数字,只要在一轮比较中交换了一次则设置为已交换,若在这一轮比较中都没有交换,则说明数组已经有序了,则设置为未交换,则提前完成了排序。
void bubbleSort(int a[]){
int len=sizeof(a)/sizeof(a[0]);
int tmp=0;
for(int i=0;i<len-1;i++){
int flag=0;//0 表示未交换,1表示交换
for(int j=0;j<len-i-1;j++){
if(a[j]>a[j+1]){
tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
flag=1;
}
}
if(!flag) return;
}
return;
}
归并排序
归并排序有两种,分别是从上往下和从下往上,这里先暂时只实现从上往下。
从上往下则是,将数组分成一半,再把各自的一半继续对半分,直到被分成一个个单独的数,然后再两两开始合并(即归并)。在归并的时候,用两个变量指向两段数字进行比较的当前数字,小的就排在前面,比向后移动该变量,另一个变量不移动,继续重复这个过程,知道所有的数字有排好序。
平均、最好、最坏时间复杂度
O
(
n
l
o
g
2
n
)
O(nlog_2n)
O(nlog2n),空间复杂度
O
(
1
)
O(1)
O(1),稳定。
void merge(int a[],int start,int mid,int end){
int *tmp=(int*)malloc((end-start+1)*sizeof(int));
int i=start,j=mid+1,k=0;
while(i<=mid && j<=end){
if(a[i]<=a[j]) tmp[k++]=a[i++];
else
tmp[k++]=a[j++];
}
while(i<=mid) tmp[k++]=a[i++];
while(j<=end) tmp[k++]=a[j++];
for(i=0;i<k;i++) a[start+i]=tmp[i];
free(tmp);
}
void merge_up2down(int a[],int start,int end){
if(a==NULL || start>=end) return;
int mid=(start+end)/2;
merge_up2down(a,start,mid);
merge_up2down(a,mid+1,end);
merge(a,start,mid,end);
}
各个排序动图可以看这个https://brilliant.org/wiki/sorting-algorithms/