各种排序

冒泡排序
首先遍历数组，对相邻两个元素进行比较，让小的排在前面，大的排在后面，每遍历完一次，就可以得到无序数中最大的一个数，且这个数就排在了正确的位置上（最后）。再对剩下的无序数进行遍历，经过n次后，整个数组就完全有序了。
平均时间复杂度$O(n^2)$ 、最坏时间复杂度$O(n^2)$，最好时间复杂度$O(n)$，空间复杂度$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(nlo{g}_{2}n)$，空间复杂度$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/