冒泡排序：定义两个指针，指向第一个和第二个位置，前一个比后一个大就交换，然后同时向后挪接着比较，把最大的放到最后一个位置。最坏的情况：O(N^2)，最好的情况：O(N)。冒泡和插入的时间复杂度差不多相同，但是当数组接近有序时，她两比起来插入好一些。
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
// 冒泡排序
void BubbleSort(int* a, int n)
{
for(int end = n; end > 0; end--)
{
int exchange = 0;
for(int i = 1; i<end; i++)
{
if(a[i-1] < a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if(exchange == 0) //如果没有发生交换，可以提前结束程序
break;
}
}
快速排序：
理想的情况下：每次排序都是二分，直到二分到最后，那就相当于递归高度次(logN)，每一层单趟排都是O(N)，时间复杂度O(NlogN)
最坏的情况：数组有序（或者接近有序）是最坏情况。假如数组是升序，key是left，要排升序，有N层，则每层都排(N,N-1,N-2…,3,2,1)，时间复杂度是O(NN)。因此，优化最差情况1.三数取中 2.小区间排序优化
相遇有两种情况：right找left或者left找right
如果是right先走，最坏在遇见left的时候停止，而这个位置是left的位置，值肯定是比key小的，但left先走的话，最坏情况遇见right，此时值是比key大的，交换会出问题。因此，left是key需要让right先走。
void QuickSort(int* a,int n)
{
int left = 0, right = n-1;
int keyi = left;
while(left < right)
{
// 找小
// 如果没有left < right可能会导致right一直--,越界访问eg：[1,2,3,4,5]
while(left < right && a[right] >= a[keyi])
--right;
// 找大
//如果没有a[left] <= a[keyi]的=符号时，可能会导致死循环eg:[5,1,2,5,6];
while(left < right && a[left] <= a[keyi])
++left;
Swap(&a[left], &a[right]);
}
Swap(&a[keyi], &a[left]);
}
第二阶段：分治（递归），对每次的key的左右区间看成子问题，传入递归一直分治，最终完成。递归结束标志：当这个子区间不存在或者只有单个值时返回。
void QuickSort(int* a, int begin, int end)
{
if(begin >= end) // 迭代的终点：左区间>=右区间时，迭代结束。
return;
int left = begin, right = end-1;
int keyi = left;
while(left < right)
{
// 找小
while(left < right && a[right] >= a[keyi])
--right;
// 找大
while(left < right && a[left] <= a[keyi])
++left;
Swap(&a[left], &a[right]);
}
int meeti = left;
Swap(&a[keyi], &a[meeti]);
//左：[begin,meeti-1] meeti 右：[meeti+1,end]
QuickSort(a, begin, meeti-1); // 传参就是[0, n-1]
QuickSort(a, meeti+1, end);
}
挖坑法：将key的位置看作是一个坑(hole)，然后利用part1的思路，找到大的将值放进坑中，然后此时right就是hole，再找小的值，将小的值放进hole中，此时left是坑…,直到相遇，把最早的key值放进相遇的坑中。
挖坑法的初次排序后的值可能和hoare的值不同。
快排最差情况的优化：三数取中。对快排影响最大的是key，如果key取值越接近中位数则越接近二分，效率越高
三数取中是在最左边，左右边和最中间的值，选择他们三个不是最大也不是最小的数。
三数取中，始终将需要的那个中间的数换到最左边的位置，这样就不用操心key位置一直变换的问题了。
// 快速排序的三数取中 优化快排的最差情况
int GetMidIndex(int* a, int left, int right)
{
int mid = (left + right) >> 1; //就是(left + right)/2
// left, mid, right
if(a[left] < a[mid])
{
if(a[mid] < a[right])
return mid;
else if(a[left] > a[right])
return left;
else
return right;
}
else // a[left] > a[mid]
{
if(a[mid] > a[right])
return mid;
else if(a[left] < a[right])
return left;
else
return right;
}
}
// 快速排序hoare版本 -- 最原始的 左右指针法
int PartSort1(int* a, int left, int right)
{
int midIndex = GetMidIndex(a, left, right); //找到中间数
Swap(&a[left], &a[midIndex]); //再交换到left位置
int keyi = left;
while(left < right)
{
// 找小
while(left < right && a[right] >= a[keyi])
--right;
// 找大
while(left < right && a[left] <= a[keyi])
++left;
Swap(&a[left], &a[right]);
}
Swap(&a[keyi], &a[left]);
return left;
}
// 迭代过程
void QuickSort(int* a, int begin, int end)
{
if(begin >= end) // 迭代的终点：左区间>=右区间时，迭代结束。
return;
int keyi = PartSort1(a, begin, end);
//左：[begin,keyi -1] keyi 右：[keyi +1,end]
QuickSort(a, begin, keyi -1); // 传参就是[0, n-1]
QuickSort(a, keyi +1, end);
}
将快排中的单趟排序独立出来
// 快速排序hoare版本 -- 最原始的 左右指针法
int PartSort1(int* a, int left, int right)
{
int keyi = left;
while(left < right)
{
// 找小
while(left < right && a[right] >= a[keyi])
--right;
// 找大
while(left < right && a[left] <= a[keyi])
++left;
Swap(&a[left], &a[right]);
}
Swap(&a[keyi], &a[left]);
return left;
}
//挖坑法：
int PartSort2(int* a, int left, int right)
{
int key = a[left];
while(left < right)
{
//找小
while(left < right && a[right] >= key )
right--;
// 放到左边的坑位，右边就是新的坑
a[left] = a[right];
//找大
while(left < right && a[left] <= key )
left++;
//放到右边的坑位，左边就是新的坑
a[right] = a[left];
}
a[left] = key;
return left;
}
// 迭代过程
void QuickSort(int* a, int begin, int end)
{
if(begin >= end) // 迭代的终点：左区间>=右区间时，迭代结束。
return;
int keyi = PartSort1(a, begin, end);
//左：[begin,keyi -1] keyi 右：[keyi +1,end]
QuickSort(a, begin, keyi -1); // 传参就是[0, n-1]
QuickSort(a, keyi +1, end);
}
