C语言：稳定排序（冒泡，插排，归并）

什么叫稳定排序呢？比如排序中有两个一摸一样的数字，如果排完序，两个相同的数字顺序没有改变，就是稳定的， 反之，就是非稳定的。

稳定排序包括：

• 冒泡：将元素不断地从已排序区交换到数组末尾的待排序区,循环n-1轮，优化：设flag，标记某一轮数组元素没有交换，则整个待排序区有序，结束排序
• 插入：不断地将待排序区数字加入到已排序区（有序），直到待排序区没有元素，循环n-1轮【有点像插队；O（n^2）
• 归并：分治思想

另外，排序算法还能分为: 内部排序、外部排序（当前数组不可以全部加载到内存中，需要分段加载）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define swap(a, b) __typeof(a) t = a; a = b; b = t
int num[1000];

//小的在前
//插排
void insert_sort(int *num, int n){//排序元素个数
	for (int i = 1; i < n; i++){
		for (int j = i; j > 0; j--){
			if (num[j] < num[j - 1]){
				swap(num[j], num[j - 1]);
			}
		}
		/*
		 * for (int j = i; j > 0 && num[j] < num[j - 1]; j--){
		 * 	swap(num[j], num[j - 1]);
		 * }
		 */
	}
	return ;
}

//冒泡
void bubble_sort(int *num, int n){
	int flag = 1;
	for (int i = 1; i < n && flag; i++){
		flag = 0;
		for (int j = 0; j < n - i; j++){//为啥我觉得是n-i+1
			if (num[j] > num[j + 1]){
				flag = 1;
				swap(num[j], num[j+1]);
			}
		}
	}
}

//归并
void merge_sort(int *num, int l, int r){
	//printf("l%d r%d \n", l, r);
	if (r - l <= 1){//两个元素以内
		if (r - l == 1 && num[r] < num[l]){
			swap(num[r], num[l]);
		}
		return;
	}
	//中分
	int mid = (l + r) >> 1;
	merge_sort(num, l, mid);
	merge_sort(num, mid + 1, r);
	//回溯
	//开辟新的空间,将排序好的数往里面放
	int *temp = (int *)malloc(sizeof(int) * (r - l + 1));
	int p1 = l, p2 = mid + 1, k = 0;
	while(p1 <= mid || p2 <= r){//还有元素待插入
		if(p2 > r || (p1 <= mid && num[p1] <= num[p2])){//把p1条件去掉？
			temp[k++] = num[p1++];
		}else{
			temp[k++] = num[p2++];
		}
	}
	memcpy(num + l, temp, sizeof(int) * (r - l + 1));
	free(temp);
	return ;
}

void out(int *arr, int n){
	for(int i = 0; i < n; i++){
		printf("%d ", arr[i]);
	}
	printf("\n");
}


int main(){
	srand(time(0));
#define maxop 20
	int arr[maxop];
	int n = maxop;
	while(n--){
		arr[n] = rand() % 100;
	}
	out(arr, maxop);
	int test[maxop];
	memcpy(test, arr, sizeof(int)*maxop);
	//printf("insert:");
	//insert_sort(test, maxop);
	//printf("bubble:");
	//bubble_sort(test, maxop);
	printf("merge:");
	merge_sort(test, 0, maxop-1);
	out(test, maxop);
#undef maxop
}