数据结构的常见五种排序（C++）

数据结构的常见五种排序（C++）

冒泡排序

时间复杂度（平均）：O(n^2)
时间复杂度（最坏）：O(n^2)
时间复杂度（最好）：O(n)
稳定性：稳定

原理：从前到后两两比较，顺序错误就交换。第i轮，将比较n-i-1次，由于每一轮，都将现存最大一个值，排序到最后。
时间复杂度：(n-1)+(n-2)+(n-3)+…+1 = n(n-1)/2

vector<int>& BubbleSort::bubble(vector<int>& a) {
	int len =a.size();
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (a[j] > a[j+1]) {
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	return a;
}

选择排序

时间复杂度（平均）：O(n^2)
时间复杂度（最好）：O(n^2)
时间复杂度（最坏）：O(n^2)
稳定性：不稳定

原理：选中未排序列第一个元素为假定最小值，与后边每个值比较，选中真正的最小值，然后这个值就进入已排序列

vector<int>& SelectSort::Select(vector<int>& a) {
	int len = a.size();
	for (int i = 0; i < len; i++) {
		int minIndex = i;
		for (int j = i + 1; j < len; j++) {
			if (a[minIndex] > a[j]) {
				minIndex = j;
			}
		}
		if (minIndex != i) {
			int temp = a[i];
			a[i] = a[minIndex];
			a[minIndex] = temp;
		}
	}
	return a;
}

插入排序

时间复杂度（平均）：O(n^2)
时间复杂度（最好）：O(n)
时间复杂度（最差）：O(n^2)
稳定性：稳定

原理：分为两个序列，已排序列和未排序列，分别抽取未排序列的每一个，插入已排序列。

vector<int>& InsertionSort::Insertion(vector<int>& a) {
	int len = a.size();
	//i无序序列第一个下标
	//j有序序列最后一个下标
	int i = 1;
	while (i < len) {
		int j = i - 1;
		int ItemToInsertion = a[i];
		while (j >= 0) {
			if (a[j] >= ItemToInsertion) {
				a[j + 1] = a[j];
				j--;
			}
			else
				break;
		}
		a[j + 1] = ItemToInsertion;
		i++;
	}
	return a;
}

快速排序

时间复杂度（平均）：O（nlog2n）
时间复杂度（最好）：O（nlog2n）
时间复杂度（最坏）：O（n^2）

原理：选择一个基准，将小于该基准的值放在左边，大于该基准的值放在右边
时间复杂度：
1、n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。
2、划分之后一边是一个，一边是n-1个，这种极端情况的时间复杂度就是O(N^2)
3、最好的情况是每次都能均匀的划分序列，O(N*log2N)

void QuickSort::quicksort(vector<int>& a, int left, int right) {
	if (left > right) {
		return;
	}
	int i = left;
	int j = right;
	int base = a[left];
	while (i != j) {
		while (a[j] >= base && i < j) {
			j--;
		}
		while (a[i] <= base && i < j) {
			i++;
		}
		if (i < j) {
			int temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
	}
	a[left] = a[i];
	a[i] = base;

	quicksort(a, left, i - 1);
	quicksort(a, i + 1, right);
}

希尔排序

时间复杂度（平均）：O(nlgn)
时间复杂度（最好）：O(nlg^2n)
时间复杂度（最坏）：O(nlg^2n)
稳定性：不稳定

vector<int>& ShellSort::shell(vector<int>& a) {
	int len = a.size();
	for (int i = len / 2; i >= 1;i /= 2) {
		for (int j = i; j < len; j++) {
			int ItemTOInsertion = a[j];
			int k = j - i;
			while (k >= 0 && a[k] >= ItemTOInsertion) {
				a[k + i] = a[k];
				k = k - i;
			}
			a[k + i] = ItemTOInsertion;
		}
	}
	return a;
}