数据结构 第七章 排序——冒泡排序，快速排序
冒泡排序：
void Bubble_Sort( ElementType a[], int n )
{
int i, k;
for( k = n - 1; k > 0; k-- ){ //外部循环，每一次冒泡结束后最后一个位置的元素总是有序的，所以在下一次排序时就不需要比较它
int flag = 0; //标记设为0
for( i = 0; i < k; i++ ){ //内部循环，每一趟冒泡都从下标为0的元素开始比较直到下标为k-1的元素比较完为止
if( a[i] > a[ i + 1 ] ){ //发现一个逆序对，就交换它
int tmp = a[i];
a[i] = a[ i + 1 ];
a[ i + 1 ] = tmp;
flag = 1; //如果这一趟冒泡排序发生过元素的交换，就把标记设为1
}
}
if( flag == 0 ) //如果这一趟冒泡没有发生过元素的交换，也就是说所有的数据已经有序了，就跳出循环
break;
}
}
空间效率：借助常数的辅助单元，所以空间复杂度为O（1）。
时间效率：
（1）最好情况：数据本身是顺序的，此时需要一趟冒泡，n-1次比较，0次交换，时间复杂度为O（n）；
（2）最坏情况：数据本身是逆序的，此时需要n-1趟冒泡，每一趟需要n - i次比较（共需要n(n - 1) / 2次），每次比较需要三次移动来交换元素位置（共需要3n(n - 1）/ 2 次移动)，时间复杂度为O（n^2）.
（3）平均时间复杂度O（n^2）。
稳定性：稳定，因为只有当两个元素逆序的时候才会交换位置，所以不会改变同样值的元素的相对位置。
快速排序：对冒泡排序的改进，基本思想是分治。
（1）主元（pivot）的选取以及子集的划分：
王道版本：每次总以当前表中第一个元素作为主元：
int partition( ElementType a[], int low, int high )
{
ElementType tmp = a[low]; //选取当前表中第一个元素作为主元，把它的值保存在临时空间里
while( low < high ){
while( low < high && a[high] >= tmp ) //比较如果后面的值比主元大，就把high指针前移
--high;
a[low] = a[high]; //循环跳出的时候说明此时后面有一个比主元小的数字，这时把这个数字放在low指针的位置
while( low < high && a[low] <= tmp ) //比较如果前面的值比主元小，就把low指针后移
++low;
a[high] = a[low]; //循环跳出的时候说明此时前面有一个比主元大的数字，这时把这个数字放在high指针的位置
}
a[low] = tmp; //最后把主元放在low的位置上，此时low指针与high指针重合
return low; //返回low就是主元最终的位置
}
MOOC陈越老师版本：取头中尾的中位数作为主元：
ElementType Median3( ElementType a[], int Left, int Right )
{
int center = ( Left + Right ) / 2;
if( a[Left] > a[center] ) //三个if语句用来把头中尾三个元素排好序，取中间的为主元
swap( &a[Left], &a[center] );
if( a[Left] > a[Right] )
swap( &a[Left], &a[Right] );
if( a[center] > a[Right] )
swap( &a[center], &a[Right] );
swap( &a[center], &a[Right - 1] ); //把中间的元素放在最后一个元素前面，这样头上的元素肯定比主元小，尾上的元素肯定比主元大
//这样就只需要对从Left + 1开始到Right- 2的所有元素进行快速排序
return a[Right - 1];
}
void swap( ElementType *a, ElementType *b )
{
int tmp = *a;
*a = *b;
*b = tmp;
}
（2）快速排序算法：
王道版本：
void QSort( ElementType a[], int low, int high )
{
if( low < high ){
int pivotpos = partition( a, low, high ); //划分子集
QSort( a, low, pivotpos - 1 ); //对子集的左半部分递归调用快速排序
QSort( a, pivotpos + 1, high ); //对子集的右半部分递归调用快速排序
}
}
void Quick_Sort( ElementType a[], int n )
{
QSort( a, 0, n - 1 );
}
MOOC陈越老师版本：
void QuickSort( ElementType a[], int Left, int Right )
{
int cutoff = 5; //设置阈值
if( cutoff <= Right - Left ){ //当要排序的序列长度等于或大于阈值时进行快速排序
ElementType pivot = Median3( a, Left, Right ); //子集的划分，得到主元值
int i = Left;
int j = Right - 1;
for( ; ; ){
while( a[++i] < pivot ){} //如果i下标对应的元素比主元值小，就继续往后递推，直到遇到一个大于主元的数，就停下来
while( a[--j] > pivot ){} //如果j下标对应的元素比主元值大，就继续往前递推，直到遇到一个小于主元的数，就停下来
if( i < j ) //如果i, j都停下来而且i比j小
swap( &a[i], &a[j] ); //就交换这两个数
else //否则表示当前序列已经排好，跳出循环
break;
}
swap( &a[i], &a[Right - 1] ); //此时i和j重合，且对应的位置就是主元这一趟快速排序最终的位置，所以把主元和当前位置元素交换
QuickSort( a, Left, i - 1 ); //对子集的左半部分递归调用快速排序
QuickSort( a, i + 1, Right ); //对子集的右半部分递归调用快速排序
}
else
Insert_Sort_Direct( a + Left, Right - Left + 1 ); //当序列的长度小于阈值时，采用简单插入排序，因为快排对小规模的数据效率可能还不如简单排序
}
void Quick_Sort_( ElementType a[], int n )
{
QuickSort( a, 0, n - 1 );
}
空间效率：快速排序不是原地排序，它使用递归所以需要使用系统递归调用栈或用户自定义栈，栈长取决于递归调用的深度，平均情况下空间复杂度为O（logn），最坏情况下O（n）。
时间效率：快速排序的运行时间取决于每一次的划分是否对称，最坏情况下每一次划分都有一个子序列长度为0（如果总选取第一个元素作为主元的话，这种情况发生在当序列刚好是顺序或者逆序的时候），此时快速排序就退化成简单的冒泡排序，时间复杂度为O（n^2），所以快速排序不适合于序列原本有序或基本有序，数据次序越乱，划分的随机性越好，快速排序越快，快速排序不是自然排序。
快速排序使所有内部排序中平均性能最优的算法。
稳定性：不稳定。