数据结构复习：搞懂十大排序算法（未完）

1.排序算法概述

1.1分类：

比较类排序（非线性时间）：

通过比较来决定元素间的相对次序，由于其时间复杂度不能突破因此被称为非线性时间比较类排序。

非比较类（线性时间）：

不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界以线性时间运行。

1.2算法复杂度

2.插入排序

2.1简单插入排序

将数组分为有序序列和无序序列两部分（有序在前，无序在后，初始时有序序列为空）

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

//简单插入排序
void InsertionSort(int* array,int length )
{
	//从头开始
	for(int i=1;i<length;i++){
		int j = i - 1;
		int value = array[i];
		//向前比较
		while (j >= 0 && array[j] > value) {
			array[j + 1] = array[j];
			j--;
		}
		//插到后面
		array[j+1] = value;
	}
}

2.2希尔排序

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

void shellSort(int *array, int length) 
{
	int number = length / 2;
	while (number >= 1) {
		for (int i = number; i < length; i++) {
			int j = i - number;
			int val = array[i];
			while (j >= 0 && array[j]>val) {
				array[j + number] = array[j];
				j -= number;
			}
			array[j + number] = val;
		}
		number = number / 2;
	}
}

3.归并排序

3.1二路归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。 

1. 把长度为n的输入序列分成两个长度为n/2的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

//二路归并
void MergeSort(int *array,int l,int r)
{

	if (l < r) {
		int m = (l + r) / 2;
		MergeSort(array,l, m);
		MergeSort(array, m + 1, r);
		Merge(array,l,m,r);
	}
}
void Merge(int *array, int l, int m, int r) {
	int countL = m - l + 1;
	int countR = r - m;
	int *arrayL = new int[countL];
	int *arrayR = new int[countR];
	for (int i = 0; i < countL; i++) {
		arrayL[i] = array[l+i];
	}
	for (int i = 0; i < countR; i++) {
		arrayR[i] = array[m + i+1];
	}
	int i = 0; 
	int j = 0;
	int k = l;
	while(i<countL&& j<countR) {
		if (arrayL[i] <= arrayR[j]) {
			array[k] = arrayL[i++];
		}
		else {
			array[k] = arrayR[j++];
		}
		k++;
	}
	while (i < countL) {
		array[k++] = arrayL[i++];
	}
	while (j<countR) {
		array[k++] = arrayR[j++];
	}
}

 

 

快排

//快速排序（从小到大）
void quickSort(int left, int right, vector<int>& arr)
{
	if(left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		while (arr[j] >= base && i < j)
			j--;
		while (arr[i] <= base && i < j)
			i++;
		if(i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[i];
	arr[i] = base;
	quickSort(left, i - 1, arr);//递归左边
	quickSort(i + 1, right, arr);//递归右边
}