C++经典排序算法

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

1.插入排序

每步将一个待排序的对象，按其关键码的大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部循环为止。

void insertSort(vector<int>& nums)
{
	int len = nums.size();
	for (int i = 1; i < len; ++i)
	{
		if (nums[i] < nums[i - 1])
		{
			int j = i - 1;//指向i之前的数 与i进行对比
			int temp = nums[i];//先将nums[i]存在变量temp中，
			while (j>=0 && temp < nums[j])
			{
				nums[j + 1] = nums[j];
				j--;
			}
			nums[j + 1] = temp;
		}
	}
}

2.希尔排序

先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录”基本有序”时，再对全体记录进行一次直接插入排序。

void shellSort(vector<int> &nums)
{
	int size = nums.size();
	int gap = size;
	while (gap > 1) {
		gap = gap / 2;
		for (int i = 0; i < size - gap; i++) {
			if (nums[i + gap] < nums[i]) {
				int end = i;
				int temp = nums[end + gap];
				while (end >= 0 && temp < nums[end])
				{
					nums[end + gap] = nums[end];
					end -= gap;
				}
				nums[end + gap] = temp;
			}
		}
	}
}

3.冒泡排序

void bubbleSort(vector<int> &nums)
{
	int size = nums.size();
	for (int i = 0; i < size; i++) {
		for (int j = i + 1; j < size; j++) {
			if (nums[j] < nums[i]) {
				int tmp = nums[i];
				nums[i] = nums[j];
				nums[j] = tmp;
			}
		}
	}
}

4.快速排序

1. 任取一个元素（如：第一个）为中心
2. 所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子表。
3. 对各字表重新选择中心元素并依此规则调整。（递归思想）
4. 直到每个子表的元素只剩一个

void quickSort(vector<int> &nums,int left,int right)
{
	if (left >= right) return;
	int low = left;
	int high = right;
	int key = nums[left];
	while (left < right)//left==right退出循环
	{
		//从后往前走，将比基准小的移到前面
		while (left < right && nums[right] > key){
			right--;
		}
		if (left < right){
			nums[left++] = nums[right];
		}
		//从前往后走，将比第一个大的移到后面
		while (left < right && nums[left] <= key){
			left++;
		}
		if (left < right){
			nums[right--] = nums[left];
		}

		nums[left] = key;
		//递归key前部分
		quickSort(nums, low, left - 1);
		//递归key后部分
		quickSort(nums, left + 1, high);
	}
}

5.选择排序

选择排序是从头到尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。

void selectSort(vector<int> &nums)
{
	int size = nums.size();
	for (int i = 0; i < size; i++) {
		int min = nums[i];
		int min_index = i;
		for (int j = i + 1; j < size; j++) {
			if (nums[j] < min) {
				min = nums[j];
				min_index = j;
			}
		}
		if (min_index == i)
			continue;
		else {
			for (int j = min_index; j >= i + 1; j--) {
				nums[j] = nums[j - 1];
			}
			nums[i] = min;
		}
	}
}

6.归并排序

归并排序（Merge Sort）就是将已经有序的子数列合并，得到另一个有序的数列。归并排序也就是合并排序。

void mergeSort(vector<int> &nums, vector<int> &nums_tmp, int start, int end)
{
	if (start >= end) return;
	int mid = start + (end - start) / 2;
	int start1 = start;
	int end1 = mid;
	int start2 = mid + 1;
	int end2 = end;
	mergeSort(nums_tmp, nums, start1, end1);
	mergeSort(nums_tmp, nums, start2, end2);

	int j = start;//已排序数组nums_temp的计数器

	//将区间左右两边数组合并到已排序数组中
	while (start1 <= end1 && start2 <= end2)
	{
		if (nums[start1] < nums[start2])
		{
			nums_tmp[j] = nums[start1];
			j++;
			start1++;
		}
		else
		{
			nums_tmp[j] = nums[start2];
			j++;
			start2++;
		}
	}
	//把左边数列其它的元素追加到已排序数组
	while (start1 <= end1)
	{
		nums_tmp[j] = nums[start1];
		j++;
		start1++;
	}
	//把右边数列其它的元素追加到已排序数组
	while (start2 <= end2)
	{
		nums_tmp[j] = nums[start2];
		j++;
		start2++;
	}
    nums.assign(nums_tmp.begin(), nums_tmp.end());
}

?