本文簡單介紹幾種面試中常用的排序演算法，並對每個演算法的時間複雜度、空間複雜度、穩定性進行分析。

(1) 氣泡排序

void swap(int& num1, int& num2)
{
	num1 = num1 ^ num2;
	num2 = num2 ^ num1;
	num1 = num1 ^ num2;
}

void bubbleSort(int array[], int size)
{
	int i, j;

	for (i = 0; i < size-1; i++) {
		for (j = 0; j < size - i - 1; j++) {
			if (array[j] > array[j+1]) {
				swap(array[j], array[j+1]);
			}
		}
	}
}

int main(int argc, const char* argv[])  
{  
    /* test example */  
    int a[10] = {5, 10, 8, 2, 4, 13, 15, 9, 1, 3};  
      
    bubbleSort(a, 10);  
      
    for (int i=0; i<sizeof(a)/sizeof(*a); i++) {  
        cout << a[i]<< ',';  
    }  
      
    cout<<endl;  
      
    return 0;  
} 
 

時間複雜度O(n^2)，空間複雜度O(1)。

(2) 選擇排序

(3) 插入排序

(4) 快速排序

void quicksort(int* num, int start, int endend)
{
	int i = start;
	int j = end;
	int value = num[end];  // 以value為標準進行比較
	
	if (end <= start) return;
	
	while (i < j) {
		/* 從前往後找比value大的數 */
		for (; i < j; i++) {
			if (num[i] > value) {
				num[j--] = num[i];
				break;
			} 
		}
		
		/* 從後往前找比value小的數 */
		for (; i < j; j--) {
			if (num[j] < value) {
				num[i++] = num[j];	
				break;
			} 
		}
	}
	
	num[i] = value;
	
	quicksort(num, start, i-1);
	quicksort(num, i+1, end);
}

void printArray(int* num, int start, int end)
{
	for (int i = start; i < end; i++) {
		cout << num[i] << ",";
	}
	cout << endl;
}

int main(int argc, char* argv[])
{
	/* test example */
	int array[10] = {5, 10, 8, 2, 4, 13, 15, 9, 1, 3};
	
	quicksort(array, 0, 9);
	
	printArray(array, 10);
	
	return 0;
}
 

(5) 堆排序

堆排序是指利用堆積樹（堆）這種資料結構所設計的一種排序演算法。

堆分為大根堆和小根堆，兩者都是完全二叉樹（完全二叉樹的知識請自行學習）。大根堆的要求就是每個節點的值都不大於其父節點的值，即 node->parent->value >= node->value。小根堆則於此相反，每個節點的值都不小於其父節點的值。因為大根堆和小根堆的性質相似，本文僅以大根堆為例進行討論。

由大根堆的性質可知，一組數列如果為大根堆的話，那數列的最大值肯定在堆頂。堆排序就是利用此性質，不斷構建大根堆，不斷選取最大值以進行數列排序。具體過程如下：

    (1) 將一組長度為n的無序數列K0, K1, K2, ..., Kn-1構建成大根堆。

一言以敝之，就是將無序的待排序數列轉換成

/* 交換兩個數 */
void swap (int* a, int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

/* 構建最大堆 */ 
void buildHeap(int array[], int size)
{
	int i = size - 1;
	
	/* 最後一個葉節點為單葉節點時的處理 */ 
	if (0 == size % 2) {
		if (array[(i-1)/2] < array[i]) {
			swap(array[(i-1)/2], array[i]);
		}
		i--;
	}
	 
	for (; i > 0; i-=2) {
		int p = (i-2)/2;
		int j = array[i - 1] >= array[i] ? i-1 : i;
		if (array[p] < array[j]) {
			swap(array[p], array[j]);
		}
	}
}

/* 最大堆排序 */ 
void heapSort(int array[], int size)
{
	if (size > 0) {
		buildHeap(array, size);
		heapSort(array+1, size-1);
	}
}
 
int main(int argc, const char* argv[])
{
	/* test example */
	int a[10] = {5, 10, 8, 2, 4, 13, 15, 9, 1, 3};
	
	heapSort(a, 10);
	
	for (int i=0; i<sizeof(a)/sizeof(*a); i++) {
		cout << a[i]<< ',';
	}
	
	cout<<endl;
	
	return 0;
}

(6) 歸併排序

先把程式碼貼上來，有時間再將此帖寫完

/* 將有序陣列 source[start, ..., mid] 和 有序陣列 source[mid+1, ..., end]
 * 合併成一個有序陣列，並將合併的有序陣列寫回source中 */
void merge(int source[], int target[], int start, int mid, int end)
{
	int i, j, k;
	
	/* i: [start, ..., mid]部分遍歷下標，j: [mid+1, ..., end]遍歷下標 */
	for (i = start, j = mid+1, k = start; i <= mid && j <= end; k++) {
		if (source[i] <= source[j]) {
			target[k] = source[i++];
		} else {
			target[k] = source[j++];
		}
	}
	
	while (i <= mid) {
		target[k++] = source[i++];
	}
	
	while (j <= end) {
		target[k++] = source[j++];
	}
	
	for (i = start; i < k; i++) {
		source[i] = target[i];
	}
}

/* 歸併排序 */
void mergeSort(int source[], int target[], int start, int end)
{
	if (start < end) {
		int mid = (start + end) / 2;
		
		/* 對[start, ..., mid]部分進行遞迴排序 */
		mergeSort(source, target, start, mid);
		
		/* 對[mid+1, ..., end]部分進行遞迴排序 */
		mergeSort(source, target, mid+1, end);
		
		/* [start, ..., mid] 和 [mid+1, ..., end] 分別排序完成後
		 * 再將兩部分合併成一個有序陣列 */
		merge(source, target, start, mid, end);
	}
}

int main(int argc, char* argv[])
{
	/* test example */
	int a[10] = {5, 10, 8, 2, 4, 13, 15, 9, 1, 3};
	int* b = new int[10];
	
	mergeSort(a, b, 0, 9);
	
	for (int i=0; i<sizeof(a)/sizeof(*a); i++) {
		cout << b[i]<< ',';
	}
	
	cout<<endl;
	
	return 0;
}