稳定排序

关注

原创最新推荐文章于 2026-04-19 05:48:16 发布 187 阅读 AI 写同款· GEO 优化 ›

稳定排序与不稳定排序方法的分类和总结 排序算法的稳定性是指排序前 2 个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。简单来说就是，如果Ai = Aj，Ai原来在位置前，排序后Ai还是要在Aj位置前。 排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果... 阅读详情


#define swap(a, b) {\
	a ^= b, b ^= a, a ^= b; \
}

#define TEST(arr, n, func, args...) { \
	int *num = (int *)malloc(sizeof(int) * n);\
	memcpy(num, arr, sizeof(int) * n);\
	output(num, n);\
	printf("%s = ", #func);\
	func(args);\
	output(num, n);\
	free(num);\
}
//插入排序O(N2)
void insert_sort(int *num, int n) {
	for (int i = 1; i < n; i++) {
		for (int j = i; j > 0 && num[j] < num[j - 1]; j--) {
			swap(num[j], num[j - 1]);
		}
	}

	return ;
}
//冒泡排序 O(N2)
void bubble_sort(int *num, int n) {
	int times = 1;

	for (int i = 1; i < n && times; i++) {
		times = 0;
		for (int j = 0; j < n - i; j++) {
			if (num[j] <= num[j + 1]) continue;
			swap(num[j], num[j + 1]);
			times++;
		}
	}

	return ;
}
//归并排序O(NlogN)
void merge_sort(int *num, int l, int r) {
	if (r - l <= 1) {
		if (r - l == 1 && num[l] > num[r] ) {
			swap(num[l], num[r]);
		}
		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])) {
			temp[k++] = num[p1++];
		} else {
			temp[k++] = num[p2++];
		}
	}
	memcpy(num + l, temp, sizeof(int) * (r - l + 1));
	free(temp);
	return ;
}

void randint(int *num, int n) {
	while(n--) num[n] = rand() % 100;
	return;
}

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

int main() {
	srand(time(0));
#define max_op 22
	int arr[max_op] = {0};
	randint(arr, max_op);

	TEST(arr, max_op, insert_sort, num, max_op);
	TEST(arr, max_op, bubble_sort, num, max_op);
	TEST(arr, max_op, merge_sort, num, 0, max_op - 1);

	return 0;
}