快速排序

快速排序：冒泡排序的升级，也是通过就比较和交换来实现。通过一趟排序将要排序的数据分割成两部分，其中一部分的所有数据都要比另一部分的所有数据小，然后在按照此方法对着两个部分的数据分别进行快速排序。
算法过程：
(1)假设要求序列递增，首先设定一个基准值，通过该基准值将数组分成左右两部分。
(2)将大于或等于基准值的数据集中到数组右边，小于基准值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于基准值，而右边部分中各元素都大于或等于基准值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个基准值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程，可以得到这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
C++代码实现：

void quick_sort(int arr[], int left, int right)
{
       if (right <= left)
       {
              return;
       }
       int i = left;
       int j = right;
       int key = arr[left];//保存基准数，基准值设置为左边
       while (i != j)
       {
              while (arr[j] >= key && i < j)//右边先开始寻找
              {
                      --j;
              }
              while (arr[i] <= key && i < j)
              {
                      ++i;
              }
              if (i < j)
              {
                      int tmp = arr[i];
                      arr[i] = arr[j];
                      arr[j] = tmp;
              }
       }
       //把基准值归位
       arr[left] = arr[i];
       arr[i] = key;
       //基准值左右两边按照上述方法进行排序
       quick_sort(arr,left, i - 1);
       quick_sort(arr, i + 1, right);
}
int main()
{
       int arr[] = { 2,7,4,5,8,3,1 };
       int len = sizeof(arr) / sizeof(arr[0]);
       for (int i = 0; i < len; ++i)
       {
              cout << arr[i] << " ";
       }
       cout << endl;
       //将元素递增排序
       quick_sort(arr, 0, len - 1);
       for (int i = 0; i < len; ++i)
       {
              cout << arr[i] << " ";
       }
       system("pause");
       return 0;
}

结果：

算法分析：
快速排序的一次划分算法从两头交替寻找，直到left和right重合，其时间复杂度是O(n)；整个快速排序算法的时间复杂度与划分的趟数有关。
理想情况下，每次划分所选择的中间数恰好将当前序列几乎等分。此时算法的时间复杂度为O(nlogn)。
最坏情况下，每次所选的中间数是当前序列中的最大或最小元素，使得每次划分后基准值的一个部分为空。此时时间复杂度为O(n^2)。
为改善最坏情况下的时间性能,可以采用“三者值取中”方法，即比较arr[left].key、arr[right].key与arr[(left+right)/2].key，取三者中关键字为中值的元素为中间数。
快排的其他方法如下：

//三数区中，确定基准值
int get_mid(int arr[], int left, int right)
{
	int mid = left + (right - left) / 2;
	if (arr[left] <= arr[right])
	{
		if (arr[mid] < arr[left])
		{
			return left;
		}
		else if (arr[mid]>arr[right])
		{
			return right;
		}
		else
		{
			return mid;
		}
	}
	else
	{
		if (arr[mid] < arr[right])
		{
			return right;
		}
		else if (arr[mid]>arr[left])
		{
			return left;
		}
		else
		{
			return mid;
		}
	}
}
//左右指针法，就是上述方法
int part_sort1(int arr[], int left, int right)
{
	if (right <= left)
	{
		return 0;
	}
	int i = left;
	int j = right;
	int mid = get_mid(arr, left, right);
	swap(arr[mid], arr[left]);
	int key = arr[left];//保存基准数，基准值设置为左边
	while (i != j)
	{
		while (arr[j] >= key && i < j)//右边先开始寻找
		{
			--j;
		}
		while (arr[i] <= key && i < j)
		{
			++i;
		}
		if (i < j)
		{
			int tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
	}
	//把基准值归位
	arr[left] = arr[i];
	arr[i] = key;
	return i;
}
//挖坑法
int  part_sort2(int arr[], int left, int right)
{
	int mid = get_mid(arr, left, right);
	swap(arr[mid], arr[left]);
	int key = arr[left];//初始坑位，基准值
	int i = left;
	int j = right;
	while (i < j)
	{
		while (i < j && arr[j] >= key)//从右边开始寻找
		{
			--j;
		}
		arr[i] = arr[j];//找到小于基准值的数，把他放入坑位，此时这个小于基准值的数的位置就是新的坑位
		while (i < j && arr[i] <= key)//左边开始寻找大于基准值的数
		{
			++i;
		}
		arr[j] = arr[i];//找到后放入新的坑位，此数的位置为新的坑位
	}
	arr[i] = key;//基准值归位
	return i;
}
//前后指针法
int part_sort3(int arr[], int left, int right)
{
	int mid = get_mid(arr, left, right);
	swap(arr[mid], arr[left]);
	int key = arr[left];//基准值设置在左边
	int cur = right;//保存最右边的元素位置
	int pre = cur + 1;//指向cur的下一个位置
	while (cur > left)
	{
		while (arr[cur] > key && --pre != cur)//从右向左找大于key的元素，（前置++，先++后使用）
		{
			//把大于key值得元素移动到右边
			int tmp = arr[cur];
			arr[cur] = arr[pre];
			arr[pre] = tmp;
		}
		--cur;//从右边开始寻找，不符合arr[cur]>key，则cur一直向左移动，pre一直不动，直到找到arr[cur]>key
	}
	//把基准值归位
	swap(arr[--pre], arr[left]);//pre中保存的是交换后的大于key的值，所以--pre.
	return pre;
}
void quick_sort(int arr[], int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int index = part_sort3(arr, left, right);
	quick_sort(arr, left, index-1);
	quick_sort(arr, index + 1, right);
}
int main()
{
	int arr[] = { 2,7,4,5,8,3,1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < len; ++i)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	//将元素递增排序
	quick_sort(arr, 0, len - 1);
	for (int i = 0; i < len; ++i)
	{
		cout << arr[i] << " ";
	}
	system("pause");
	return 0;
}

快速排序的平均时间复杂度是O(nlogn)
快速排序的空间复杂度为O(logn))。
快速排序不是稳定的排序算法。
注：从右边开始寻找？
上述算法实现的是将一个序列递增排序。并且基准值设置了左边。那么从右边开始寻找，最终和基准值交换的数值一定比基准值小，（因为从右边开始寻找小于基准值的数值）。若从左边先开始，最后和基准值交换的数值会比基准值大，此时就不符合算法要求。所以从那边先开始寻找，看情况。

快速排序和冒泡排序都是交换排序算法
冒泡排序算法：https://blog.csdn.net/qq_44978057/article/details/100749094