排序算法的比较

如何分析一个排序算法

学习一个排序算法，除了学习他的原理，代码实现之外，更重要的是学会如何评价，分析一个排序算法，那么分析一个排序算法要从哪几个方面入手呢？
1.最好情况，最坏情况，平均时间复杂度
2.时间复杂度的系数，常数，低阶
3.比较次数和交换(或移动)次数

排序算法的内存消耗

我们前面说过，算法的内存消耗可以通过空间复杂度来衡量，排序算法也不例外，不过，针对排序算法的空间复杂度，我们还引入了一个新的概念，原地排序，指的就是空间复杂度O(1)的排序算法。

排序算法的稳定性

仅仅用执行效率和内存消耗来评价一个排序算法是不够的，针对排序算法，我们还有一个重要的指标，稳定性。这个概念说的是，如果待排序的序列中存在相同值得元素，经过排序之后，相等元素之间原来的先后顺序不变就是稳定排序。

冒泡排序

相邻的2个元素相互比较，每次循环至少会让一个元素移动到他应该在的位置，重复执行n此循环就完成了冒泡。

冒泡排序的时间复杂度是多少

最好的情况下，要排的数据已经是有序的了，我们只需要一次冒泡操作就可以结束了，所以最好的情况是O(n)，最坏的情况是数据是倒序，那么就是O(n2);

example

int a[10] = { 0,2,3,8,5,4,7,1,6,9 };
int n = 10;
for (int i = 0; i < n; i++) {
	bool flag = false;
	for (int j = 0; j < n-i-1; ++j) {
		if (a[j] > a[j+1]) {
			int temp = a[j];
			a[j] = a[j+1];
			a[j] = temp;
			flag = true;
		}
	}
	if (!flag) break;
}

插入排序

void insertionSort() {
	int arr[] = { 9,2,1,7,3,6,5,4,8,1 };
	int n = 10;
	if (n <= 1) return;
	for (int i = 1; i < n; i++) {
		int value = arr[i];
		int j = i - 1;
		for (; j >= 0; j--) {
			if (arr[j] > value) {
				arr[i] = arr[j];
			}
			else { break; }
		}
		arr[j+1] = value;
	}
}

插入排序的时间空间和稳定性分析

最好情况就是完全有序，就是O(n),如果是倒序就是O(n2),平均复杂度为O(n2),且是稳定排序，空间复杂度是O(1),也就是说是一个原地排序算法

选择排序

void selectionSort() {
	int arr[] = { 9,2,20,1,7,3,6,5,4,8,1,0,100 };
	int n = 13;
	for (int i = 0; i < n; i++) {
		int value = arr[i];
		int minIdex = i;
		for (int j = i+1; j < n; j++) {
			if (arr[j] < arr[minIdex]) {
				minIdex = j;
			}
		}

		if (i != minIdex) {
			arr[i] = arr[minIdex];
			arr[minIdex] = value;
		}
	}
}

空间复杂度是O(1)
时间复杂度为最好，最坏，平均都为O(n2),且是不稳定的排序方式

快速排序

int partition(int arr[], int low, int height) {
	cout << "low: " << low << " height:" << height << endl;
	int pivotValue = arr[low];
	while (low < height) {
		while (low<height && arr[height]>pivotValue){
			height--;
		}

		arr[low] = arr[height];

		while (low<height && arr[low]<=pivotValue){
			low++;
		}
		arr[height] = arr[low];
	}
	arr[low] = pivotValue;
	return low;
}

void quickSort(int arr[],int low,int height) {
	if (low >= height) return;
	int pivot = partition(arr, low, height);
	quickSort(arr, low, pivot-1);
	quickSort(arr, pivot+1, height);
}


int main()
{

	int arr[] = { 9,2,20,1,7,3,6,5,4,8,1,0,100 };
	quickSort(arr, 0, 12);
	cout << arr << endl;
}

时间复杂度:O(nlogn)