排序算法总结

快速排序算法

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序算法的特性：

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

2. 时间复杂度：O(N*logN）

3. 空间复杂度：O(logN)

4. 稳定性：不稳定

   快速排序算法c++递归实现

void quicklySort(vector<int>& nums,int left, int right)
{
	int i = left;
	int j = right;
	int div = i;     //标记值的下标

	if (left >= right)
	{
		return;
	}
	while (i != j)
	{
		while (nums[j] >= nums[div] && i < j)
		{
			j--;
		}

		if (i < j)
		{
			swap(nums[j], nums[div]);
			div = j;
		}

		while (nums[i] <= nums[div] && i < j)
		{
			i++;
		}

		if (i < j)
		{
			swap(nums[i], nums[div]);
			div = i;
		}
	}
	
	quicklySort(nums,left, div);
	quicklySort(nums, div + 1, right);
}

堆排序算法

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

堆排序的特性：

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
5. 适用于处理少量数据，大量数据时一般用快速排序

堆排序算法的c++实现：

#include <iostream>
#include <vector>
using namespace std;
#define left(x) 2*x+1   //获得左节点在数组中的下标
#define right(x) 2*(x+1)  //获得右节点在数组中的下标

// a 要被排序的数组 i根节点的坐标 low,high要被维护的下标 
void maxHeapify(vector<int> &a, int i, int low, int high)   //维护最大堆
{
	int l = left(i);
	int r = right(i);
	int largest;     //保存i，l，r 三节点中最大数的下标

	if (l <= high && a[l] > a[i])
	{
		largest = l;
	}
	else
	{
		largest = i;
	}

	if (r <= high && a[r] > a[largest])
	{
		largest = r;
	}

	if (largest != i)         //将最大值移至所要维护的堆顶
	{
		swap(a[i], a[largest]);
		maxHeapify(a, largest, low, high);
	}
}

void buildMaxHeap(vector<int> &a, int length)  //建堆
{
	for (int i = length / 2 - 1; i >= 0; i--)   //从最后一个非叶子结点开始
	{
		maxHeapify(a, i, 0, length - 1);
	}
}

void heapSort(vector<int> &a, int length)    //堆排序
{
	buildMaxHeap(a, length);      //构建最大堆

	for (int i = length - 1; i >= 1; i--)
	{
		swap(a[i], a[0]);
		maxHeapify(a, 0, 0, i - 1);
	}
}
int main()
{
	vector<int> a = { 49，38，65，97，76，13，27，49};
	heapSort(a, a.size());

	for (auto &i : a)
	{
		cout << i << " ";
	}
	return 0;
}

排序的过程：
此处只举例第一次排序的过程

49，38，65，97，76，13，27，49
49，38，65，97，76，13，27，49
27，38，65，97，76，13，49，49
27，38，65，97，76，13，49，49
27，38，49，97，76，13，65，49
27，38，13，97，76，49，65，49
27，38，13，49，76，97，65，49

冒泡排序算法

是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序的特性：

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

冒泡排序算法的c++实现：

#include <iostream>
using namespace std;
#include <vector>

void bubbleSort(vector<int> & nums)
{
	int len = nums.size();
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (nums[j] > nums[j+1])
			{
				swap(nums[j+1], nums[j]);
			}
		}
	}
}
int main()
{
	vector<int> a = { 4, 7, 6, 8, 5, 3, 2, 1 };
	bubbleSort(a);

	for (auto &i : a)
	{
		cout << i << " ";
	}
	return 0;
}