七大排序算法原理及实现代码【C/C++ STL】

1.时空复杂度及稳定性

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
• 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 
   

2.冒泡排序（最小/大的沉底）

上图所示的是第一趟排序，可以保证将最大的数字移动到最后面。总的步骤就是：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

code

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

3.选择排序（选择最小/大的）

• 每一次都在第i个数的后面找到最小的值，即[i+1, n)，然后和第i个数交换。

code

void selectSort(vector<int>& nums)
{
	int n = nums.size();
	int minPos = 0;
	for (int i = 0; i < n - 1; ++i)
	{
		minPos = i;
		for (int j = i + 1; j < n; ++j)
		{
			if (nums[j] < nums[minPos])
				minPos = j;
		}
		swap(nums[i], nums[minPos]);
	}
}

4.插入排序

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

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

code

void insertionSort(vector<int>& nums)
{
	int n = nums.size();
	int preIndex = 0, currentValue = 0;
	for (int i = 1; i < n; ++i)
	{
		preIndex = i - 1;
		currentValue = nums[i];
		while (preIndex >= 0 && nums[preIndex] > currentValue)
		{
			nums[preIndex + 1] = nums[preIndex];//后移操作
			--preIndex;
		}
		nums[preIndex + 1] = currentValue;
	}
}

5.希尔排序

首先它把较大的数据集合分割成若干个小组（逻辑上分组），然后对每一个小组分别进行插入排序，此时，插入排序所作用的数据量比较小（每一个小组），插入的效率比较高。

可以看出，他是按下标相隔距离为4分的组，也就是说把下标相差4的分到一组，比如这个例子中a[0]与a[4]是一组、a[1]与a[5]是一组...，这里的差值（距离）被称为增量。

每个分组进行插入排序后，各个分组就变成了有序的了（整体不一定有序）。

此时，整个数组变的部分有序了（有序程度可能不是很高）。

然后缩小增量为上个增量的一半:2，继续划分分组，此时，每个分组元素个数多了，但是，数组变的部分有序了，插入排序效率同样比高。

同理对每个分组进行排序（插入排序），使其每个分组各自有序。

最后设置增量为上一个增量的一半：1，则整个数组被分为一组，此时，整个数组已经接近有序了，插入排序效率高。

 

code

void shellSort(vector<int>& nums)
{
	int n = nums.size();
	for (int gap = n / 2; gap > 0; gap /= 2)
	{
		for (int i = gap; i < n; ++i)
		{
			int j = i;
			int current = nums[i];
			while (j - gap >= 0 && nums[j - gap] > current)
			{
				nums[j] = nums[j - gap];
				j -= gap;
			}
			nums[j] = current;
		}
	}
}

6.归并排序

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

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

code

void merge(vector<int>& nums, int left, int mid, int right);
void mergeSort(vector<int>& nums, int left, int right)
{
	if (left < right)
	{
		int mid = left + (right - left) / 2;
		mergeSort(nums, left, mid);
		mergeSort(nums, mid + 1, right);
		merge(nums, left, mid, right);
	}
}

void merge(vector<int>& nums, int left, int mid, int right)
{
	vector<int> temp;
	int i = left, j = mid + 1;
	while (i <= mid && j <= right)
	{
		if (nums[i] <= nums[j])
			temp.push_back(nums[i++]);
		else
			temp.push_back(nums[j++]);
	}
	while (i <= mid)
	{
		temp.push_back(nums[i++]);
	}
	while (j <= right)
	{
		temp.push_back(nums[j++]);
	}
	for (i = 0; i < (int)temp.size(); ++i)
	{
		nums[left + i] = temp[i];
	}
}

 

7.快速排序

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

code

void quickSort(vector<int>& nums, int start, int end)
{
	if (start < end)
	{
		int left = start, right = end;
		int pivot = nums[left];
		while (left < right)
		{
			while (left < right && nums[right] <= pivot)//从大到小排序
				--right;
			if (left < right)
				nums[left] = nums[right];
			while (left < right && nums[left] >= pivot)
				++left;
			if (left < right)
				nums[right] = nums[left];
		}
		nums[left] = pivot;
		quickSort(nums, start, left - 1);
		quickSort(nums, left + 1, end);
	}
}

8.堆排序

直接看图

code

void heapify(vector<int>& tree, int n, int i)//heapify会导致只排序root一边的节点，另一边不会递归到，
{											 //heapify()是只处理一个数，递归判断这个数的位置对不对，大了就将它飘上去
	if (i >= n)								 //heapify递归方便砍节点时重建堆
		return;
	int c1 = 2 * i + 1;
	int c2 = 2 * i + 2;
	int max = i;
	if (c1 < n && tree[c1] > tree[max])
		max = c1;
	if (c2 < n && tree[c2] > tree[max])
		max = c2;
	if (max != i)
	{
		swap(tree[i], tree[max]);
		heapify(tree, n, max);
	}
}

void build_heap(vector<int>& tree, int n)//建立大根堆
{
	int last_node = n - 1;
	int parent = (last_node - 1) / 2;
	for (int i = parent; i >= 0; --i)
		heapify(tree, n, i);
}

void heapSort(vector<int>& tree, int n)
{
	build_heap(tree, n);
	for (int i = n - 1; i >= 0; --i)
	{
		swap(tree[i], tree[0]);
		heapify(tree, i, 0);
	}
}