数据结构 第七章 排序——冒泡排序，快速排序

冒泡排序：

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），所以快速排序不适合于序列原本有序或基本有序，数据次序越乱，划分的随机性越好，快速排序越快，快速排序不是自然排序。
快速排序使所有内部排序中平均性能最优的算法。
稳定性：不稳定。