交換排序：通過依次交換逆序的元素使其有序化的過程。

介紹兩種交換排序： 氣泡排序，快速排序

冒泡法：從第一個元素開始，依次比較相鄰的兩個元素，如果逆序則交換，第一趟比較結束後，序列中最大的元素將移動到序列末尾，即第n個位置，第二趟將次大元素移動到n-1位置…… 多趟比較後，會形成有序序列，排序方法類似氣泡慢慢向上浮動，因此成為冒泡法。

快速排序： 對冒泡的改進，將序列中的關鍵字和指定元素（樞軸）比較,將序列以樞軸劃分，保證樞軸大於其左邊所有數，小於其右邊所有數。

（樞軸的選取很關鍵，避免快排在區域性有序數列中退化，再次使用的三者取中法）

按照以上方法，對上次劃分的子序列進行遞迴劃分，知道每個子序列只剩下一個元素不能劃分為止，此時序列有序。

程式碼實現：

#include<iostream>
#define SIZE 21  
typedef int Sqlist[SIZE];

using namespace std;

void swap(int &a, int &b)
{
	a = a^b;
	b = a^b;
	a = a^b;
}

//==================================BubbleSort()==================================
/// @brief <對函式進行概括說明>	氣泡排序 
/// 
/// <對函式進行詳細說明>	內部排序，穩定排序，交換排序 時間複雜度：平均 O(n),最壞O(n^2)
///
/// @param [in, out] sq <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇> 陣列
/// @param [in, out] n <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>  陣列大小
///
/// @return <返回值說明，可以配合使用DocGenList或DocGenTable>	無返回值
///
/// @remark <函式特別說明>	使用引用
///
/// @code
///      <在此新增示例程式碼>
/// @endcode
void BubbleSort(Sqlist &sq, int n)
{
	cout << "氣泡排序：" << endl;
	for (int i = 0; i < n - 1; ++i)
	{
		for (int j = 0; j < n - i - 1; ++j)
		{
			if (sq[j] > sq[j + 1])
			{
				swap(sq[j],sq[j+1]);
			}
		}
	}
}
/////////////////////////////////////////////////////

//================================PivotkeySelect()================================
/// @brief <對函式進行概括說明> 樞軸選取
///
/// <對函式進行詳細說明>		三者取中  
///
//================================================================================
int PivotkeySelect(Sqlist &sq, int low, int high)
{
	int mid = low + ((high - low) >> 1);//計算陣列中間的元素的下標  

	//使用三數取中法選擇樞軸  
	if (sq[mid] > sq[high])//目標: sq[mid] <= sq[high]  
	{
		swap(sq[mid], sq[high]);
	}
	if (sq[low] > sq[high])//目標: sq[low] <= sq[high]  
	{
		swap(sq[low], sq[high]);
	}
	if (sq[mid] > sq[low]) //目標: sq[low] >= sq[mid]  
	{
		swap(sq[mid], sq[low]);
	}
	//此時，sq[mid] <= sq[low] <= sq[high]  
	return sq[low];
	//low的位置上儲存這三個位置中間的值  
	//分割時可以直接使用low位置的元素作為樞軸，而不用改變分割函數了
}

//==================================Partition()=================================
/// @brief <對函式進行概括說明> 劃分
///
/// <對函式進行詳細說明> 用樞軸將陣列劃分
///
/// @sa <可以參考的類或函式，用空格分隔，函式名稱後必須加()> PivotkeySelect()
//================================================================================
int Partition(Sqlist &sq, int low, int high)
{
	int key = PivotkeySelect(sq,low,high);					//輔助空間
	
	while (low < high)
	{
		while (low < high && sq[high] >= key)
		{
			high--;
		}
		sq[low] = sq[high];

		while (low < high && sq[low] <= key)
		{
			low++;
		}
		sq[high] = sq[low];
	}
	sq[low] = key;
	return low;
}

//==================================QuickSort()=================================
/// @brief <對函式進行概括說明> 快速排序	對冒泡的改進 不穩定
///
/// <對函式進行詳細說明>	將關鍵字與指定元素比較 遞迴 時間複雜度：平均O(nlog2^n) 最壞O(n^2)
///
/// @param [in, out] sq <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇> 陣列
/// @param [in, out] low <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇> 最小下標
/// @param [in, out] high <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇> 最大下標
///
/// @return <返回值說明，可以配合使用DocGenList或DocGenTable>  返回low
///
/// @remark <函式特別說明>
///
/// @code
///      <在此新增示例程式碼>
/// @endcode
///
/// @sa <可以參考的類或函式，用空格分隔，函式名稱後必須加()> Partition() PivotkeySelect()
//================================================================================
void QuickSort(Sqlist &sq, int low, int high)
{
	if (low < high)
	{
		int prvitloc = Partition(sq, low, high);     //將陣列一分為二  
		QuickSort(sq, low, prvitloc - 1);              //左半部分排序  
		QuickSort(sq, prvitloc + 1, high);
	}
}
 

對於n個元素的序列，第一趟經n-1此比較，選出最小的放在第一個位置，第二趟從n-1個元素中，經過n-2次比較，選出最小的放在第二個位置……直到沒有待比較的元素。

程式碼實現：

//====================================MinKey()====================================
/// @brief <對函式進行概括說明> 最小值選取
///
/// <對函式進行詳細說明> 從key位置開始，找出大小為n陣列中的最小值，並返回下標
///
/// @param [in, out] sq <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>
/// @param [in, out] n <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>
/// @param [in, out] key <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>
///

//================================================================================
int MinKey(Sqlist &sq, int n, int key)
{
	int k = key + 1;
	for (; k < n; ++k)
	{
		if (sq[k] < sq[key])                         //若小於則記錄下標  
		{
			key = k;
		}
	}
	return key;
}


//==================================SelectSort()==================================
/// @brief <對函式進行概括說明> 簡單選擇排序
///
/// <對函式進行詳細說明> n個元素，第一次n-1次比較，選出n箇中最小元素，放在序列最前面
///
/// @param [in, out] sq <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>
/// @param [in, out] n <引數說明，[in, out]表示引數的傳遞方向，需要根據情況進行選擇>
///
/// @return <返回值說明，可以配合使用DocGenList或DocGenTable> 
///
/// @remark <函式特別說明>
///
/// @code
///      <在此新增示例程式碼>
/// @endcode
///
/// @sa <可以參考的類或函式，用空格分隔，函式名稱後必須加()> MinKey() swap()
//================================================================================
void SelectSort(Sqlist &sq, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		int j = MinKey(sq, n, i);
		if (i != j)
			swap(sq[i],sq[j]);
	}
}
 

void main(void)
{
	Sqlist sq = { 49, 38, 65, 97, 76, 13, 27, 49 };
	Sqlist sq2 = { 49, 38, 65, 97, 76, 13, 27, 49 };
	Sqlist sq3 = { 49, 38, 65, 97, 76, 13, 27, 49 };
	cout << "原陣列為：" << endl;
	
	for (int i = 0; i < 8; ++i)
	{
		cout << sq[i]<<" ";
	}
	cout << endl;
////////////////////////////////////////////
	BubbleSort(sq,8);

	for (int i = 0; i < 8; ++i)
	{
		cout << sq[i] << " ";
	}
	cout << endl;
/////////////////////////////////////////////
	cout << "原陣列為：" << endl;

	for (int i = 0; i < 8; ++i)
	{
		cout << sq2[i] << " ";
	}
	cout << endl;

	QuickSort(sq2, 0, 7);
	cout << "快速排序:" << endl;
	for (int i = 0; i < 8; ++i)
	{
		cout << sq2[i] << " ";
	}
	cout << endl;
	//////////////////////////////////////
	cout << "原陣列為：" << endl;

	for (int i = 0; i < 8; ++i)
	{
		cout << sq3[i] << " ";
	}
	cout << endl;

	SelectSort(sq3, 8);
	cout << "交換排序:" << endl;
	for (int i = 0; i < 8; ++i)
	{
		cout << sq3[i] << " ";
	}
	cout << endl;
}