数据结构--排序算法复杂度及稳定性分析

1 验证各种排序算法的时间数量级

void testOP() {
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);
	int* a8 = (int*)malloc(sizeof(int) * N);
	int* a9 = (int*)malloc(sizeof(int) * N);
	int* a10 = (int*)malloc(sizeof(int) * N);
	int* a11 = (int*)malloc(sizeof(int) * N);

	for (int i = 0; i < N; i++) {
		a1[i] = rand();
	}
	memcpy(a2, a1, sizeof(int) * N);
	memcpy(a3, a1, sizeof(int) * N);
	memcpy(a4, a1, sizeof(int) * N);
	memcpy(a5, a1, sizeof(int) * N); 
	memcpy(a6, a1, sizeof(int) * N);
	memcpy(a7, a1, sizeof(int) * N);
	memcpy(a8, a1, sizeof(int) * N);
	memcpy(a9, a1, sizeof(int) * N);
	memcpy(a10, a1, sizeof(int) * N);
	memcpy(a11, a1, sizeof(int) * N);
	int begin, end;

	begin = clock();
	insertSort(a1, N);
	end = clock();
	printf("insertSort:%d\n", end - begin);

	begin = clock();
	shellSort(a2, N);
	end = clock();
	printf("shellSort:%d\n", end - begin);

	begin = clock();
	selectSort(a3, N);
	end = clock();
	printf("selectSort:%d\n", end - begin);

	begin = clock();
	selectSort2(a4, N);
	end = clock();
	printf("selectSort2:%d\n", end - begin);

	begin = clock();
	heapSort(a5, N);
	end = clock();
	printf("heapSort:%d\n", end - begin);

	begin = clock();
	bubbleSort(a6, N);
	end = clock();
	printf("bubbleSort:%d\n", end - begin);

	begin = clock();
	quickSort(a7, 0 , N - 1);
	end = clock();
	printf("quickSort:%d\n", end - begin);

	begin = clock();
	quickSort2(a8, 0 , N - 1);
	end = clock();
	printf("quickSort2:%d\n", end - begin);

	begin = clock();
	quickSortNOR(a9, 0 , N-1);
	end = clock();
	printf("quickSortNOR:%d\n", end - begin);

	begin = clock();
	mergeSort(a10, N);
	end = clock();
	printf("mergeSort:%d\n", end - begin);

	begin = clock();
	mergeSortNOR(a11, N);
	end = clock();
	printf("mergeSortNOR:%d\n", end - begin);


}
int main() {
	testOP();
	return 0;
}

运行结果如下：

从运行结果中可以大致的看出各排序算法的数量级，但不能准确的说明排序算法效率的一个顺序。

2 排序算法复杂度及稳定性分析

数据敏感指的是最好、最坏时间相差较大。

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
简单选择排序	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O(1)$	不稳定
直接插入排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
希尔排序	$O(nlogn)$~$O(n^2)$	$O(n^{1.3})$	$O(n^2)$	$O(1)$	不稳定
堆排序	$O(nlogn)$	$O(nlogn)$	$O(nlogn)$	$O(1)$	不稳定
归并排序	$O(nlogn)$	$O(nlogn)$	$O(nlogn)$	$O(n)$	稳定
快速排序	$O(nlogn)$	$O(nlogn)$	$O(n^2)$	$O(logn)$~$O(n)$	不稳定