一、三色旗问题
问题描述
有一个数组是只由0，1，2三种元素构成的整数数组，请使用交换、原地排序而不是计数进行排序：
解题思路
1.定义两个变量，i和j（下标），从index=0开始遍历
2.如果a[index]==0，swap(a[index++],a[++i]);这里index++是因为index左边不可能有==2的数据了
3.如果a[index]==1，index++;
4.如果a[index]==2，swap(a[index],a[--j]);这里index没有++是因为在右侧不知道交换过来的数据是大于1还是小于1还是等于1，留到下一轮继续判断
5.i的含义：<=i 的部分都是比1小的。所以i的初始值为-1
6.j的含义：>=j 的部分都是比1大的。所以j的初始值为n
列举实例
int a[]={1,1,2,0,1,1,0,2,0,1,2};
cpp
#include <vector>
#include <iostream>
using namespace std;
void quick(vector<int>& v)
{
int n=v.size();
int i=-1,j=n;
int idx=0;
int key=1;
while(idx<j)
{
if(v[idx]==key) idx++;
else if(v[idx]<tmp) swap(v[++i],v[idx++]);
else if(v[idx]>tmp) swap(v[--j],v[idx]);
}
}
int main()
{
int n;cin>>n;
vector<int> v(n);
for(int i=0;i<n;i++){
cin>>v[i];
}
quick(v);
for(auto e : v){
cout<<e<<" ";
}cout<<endl;
return 0
}二、分治思想
假设你是农场主，有一小块土地。你要将这块土地均匀地分成方块，且分出的方块要尽可能地大。显然一下的分法都不符合要求：
如何将一块地均匀地分成方块，并确保分出的方块是最大地呢？使用分而治之地策略！
分而治之 算法是递归的。过程包括两个步骤：
第一步：找出基线条件，这种条件必须尽可能简单。
第二步：不断将问题分解成解法相同的两个问题（不断缩小问题规模，直至找到基线条件）
能使用的最大方块有多大呢》首先找出基线条件。最容易处理的情况是，一条边的长度是另一条边的整数倍。
如果一条边长为25m，另一边长为50m，那么可使用地最大方块就是25*25的。换言之，可以将这块地分成两个这样的方块。
每次递归调用都必须缩小问题的规模。如何缩小前述问题的规模呢？我们首先找出这块地可容纳的最大方块。
可以从这块地中画出两个640*640的方块，同时余下一小块地。现在是顿悟时刻：为何不对余下的那一小块地使用同样的算法呢？
最初要划分的土地尺寸为1680*640，而现在要划分的土地更小，为640*400.适用于这小块地的最大方块，也是适用于整块地的最大方块。换言之，你将均匀划分1680*640土地的问题，简化成了640*400土地的问题
下面再次使用同样的算法。对于640*400的土地，可以从中划分出的最大方块为400*400。这将余下一块更小的土地：400*240。
可以从这块土地中划分出最大的方块余下一块更小的土地，尺寸为240*160
接下来继续划分最终余下：160*80的土地。余下的这块土地，满足基线条件，因为160是80的整数倍2倍，将这两块土地划分为两个方块后，将不会余下任何土地。
因此对最初那块地的划分，适用的最大方块为80*80
这里重申一下分治的工作原理
1.找出简单的基线条件。
2.确定如何缩小问题的规模，使其符合基线条件。
三、快速排序
对于排序算法来说，最简单的数组是什么样子的呢？其实就是根本不需要排序的数组。
也就是空数组或者只包含一个元素的数组。因此基线条件为空数组或单元素的数组。在这种情况下，只需要返回数组--根本不用排序。
cpp
void QuickSort(int arr[],int n){
if(n<2) return;
}下面我们看一下更长的数组：双元素数组。对包含两个元素的数组进行排序也很容易：
检查第一个元素是否比第二个元素小，如果不比第二个小，就交换它们的位置
那么接下来就是三元素数组。对包含三个元素的数组进行排序：
我们理所应当的想到了一开始提到的三色旗问题，和分而治之的思想。
工作原理
第一步：从数组中选取一个元素，这个元素被称为基准值。
我们暂时将数组的第一个元素用作基准值。
第二步：找出比基准值小的元素以及比基准值大的元素。
小的放到基准值左边，大的放到基准值右边。
现在数组被我们分成了三个部分：
一部分为小于基准值的所有元素
基准值(此时，基准值已经被放在了它所应在的位置)
一部分为大于基准值的所有元素
这里只是进行了分区，得到的两个子数组是无序的。单如果这两个数组是有序的，对整个数组进行排序非常容易。
如果子数组是有序的，就可以像下面这样合并并得到一个有序的数组：左边的数组+基准值+右边的数组。在这里，就是【10，15】+【33】+【 】，结果为有序数组【10，15，33】.
如何对子数组进行排序呢？
对于包含两个元素的数组(左子数组)以及空数组(右子数组)，快速排序直到如何将它们排序，因此只要对这两个子数组进行快速排序，再合并结果，就得到了一个有序数组!
代码实现
cpp
#include <bits/stdc++>
using namespace std;
void quickSort(vector<int>& v,int L,int R)
{
if(L>=R) return;
int key_val=v[L];
int i=L-1,j=R+1;
int idx=L;
while(idx<L){
if(v[idx]==key_val) idx++;
else if(v[idx]<key_val) swap(v[++i],v[idx++]);
else if(v[idx]>key_val) swap(v[--j],v[idx]);
}
quickSort(v,L,i);//将左子数组进行快排
quickSort(v,j,R);//将右子数组进行快排
//直到L==R，结束递归，每次递归都会将L-R的基准值放到合适的位置
//递归结束后所有元素都已经排好序了
}算法分析
时间复杂度：O(nlogn)
对于快排而言，最优的情况就是，每次划分的都很均匀，假设要排序n个元素，第一次划分的时候，需要对整个数组扫描一下，做n次比较的时间为T(n)。然后将数组一分为二，那么各自还需要T(n/2)的时间（注意是最好的情况，所以平分一半）。于是不断地划分辖区，我们就有了下面地不等式推断：
cpp
T(1) == 0
T(n) <= 2*T(n/2) + n
T(n) <= 2*(2*T(n/4)+n/2) + n == 4*T(n/4)+2*n
T(n) <= 4*(2*T(n/8)+n/4) + 2*n ==8*T(n/8)+3*n
...
T(n) <= nT(1) + (logn)*n == O(nlogn) 稳定性：不稳定
感谢大家！