排序算法總結C++

一、冒泡排序

算法思路： 從1到n-1，相鄰元素進行比較，每次都將較大的數向後移動，每經過一輪移動，至少有一個數是排好序的。

void bubbleSort(int* A, int n)
{
    bool sorted = false; // 整體排序標誌
    while(!sorted)
    {
        sorted = true;
        for(int i = 1; i < n; i++)
        {
            // 一旦前面的元素大於後面的元素
            if(A[i-1] > A[i])
            {
                // 則把大的元素交換到後面
                swap(A[i-1], A[i]);
                // 發生了交換，整體排序不能保證
                sorted = false;
            }
        }
        n--; // 每一輪排序至少有一個元素就緒，故可縮短帶排序數量
    }
}

二、選擇排序

算法思路： 把整個數組分爲有序序列和無序序列，每次從無序序列中選擇最小的數，放到有序序列之後。

void selectionSort(int* A, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int min_val = A[i];
		int min_index = i;
		for (int j = i + 1; j < n; j++)
		{
			if (A[j] < min_val)
			{
				min_val = A[j];
				min_index = j;
			}
		}
		swap(A[i], A[min_index]);
	}
}

三、插入排序

算法思路： 把整個數組分爲有序序列和無序序列，對於每個數，都在前面的有序序列中尋找合適的插入位置。由於對於數組來說，插入需要向後移動元素，因此複雜度較高；而對於鏈表來說，插入則不耗費什麼時間。

void insertSort(int* A, int n)
{
    for(int i = 1; i < n; i++)
    {
        int cur = A[i];
        int j = i - 1;
        // 從後往前找，遇到大的數就向後移動
        while(j >=0 && cur < A[j])
        {
            A[j+1] = A[j];
            j--;
        }   
        A[j+1] = cur;
    }
}

四、歸併排序

算法思路： 歸併排序採取分治的策略，即將數組劃分爲前後兩部分，分別進行排序，最後再將整體進行排序。整體排序只需O(n)。
$T(n) = 2T(n/2) + O(n) = O(n log n)$

void merge(int* A, int start, int mid, int end)
{
	// 合併A[lo, mi)和A[mi, hi)
	int* tmp = new int[(end - start)]; // 構造臨時數組，存放合併後的結果
	int i = 0;
	int p_first = start;
	int p_second = mid;
	while (p_first < mid && p_second < end)
	{
		tmp[i++] = A[p_first] < A[p_second] ? A[p_first++] : A[p_second++];
	}
	// 拼接剩餘數字
	while (p_first < mid)
		tmp[i++] = A[p_first++];
	while (p_second < end)
		tmp[i++] = A[p_second++];
	for (i = start; i < end; i++)
		A[i] = tmp[i - start];
	delete[] tmp;
}

void mergeSort(int* A, int start, int end)
{
	// 使用前開後閉區間
	if (end - start < 2) return;
	int mid = (start + end) >> 1;
	mergeSort(A, start, mid);
	mergeSort(A, mid, end);
	merge(A, start, mid, end);
}

五、堆排序

算法思路： 將數組組[0, n)織成最大堆，將堆頂[0]與數組最後一個元素[n-1]交換，然後對[0, n-1)恢復成大頂堆；重複以上步驟，直到數組有序（升序）。

// 返回父親，左孩子，右孩子三者較大者的index
int ProperParent(int* A, int n, int i)
{
	int max_i = i;
	int left = 2 * i + 1;
	int right = 2 * i + 2;
	// 有右孩子
	if (right < n)
	{
		if (A[i] > A[right]) 
		{
			max_i = A[i] > A[left] ? i : left;
		}
		else 
		{
			max_i = A[left] > A[right] ? left: right;
		}
	}
	// 有左孩子
	else if (left < n)
		max_i = A[i] > A[left] ? i : left;
	return max_i;
}
// 下濾，即父節點與兩個孩子中的大者交換
// O(log n)
int percolateDown(int* A, int n, int i)
{
	int j;
	while (i != (j = ProperParent(A, n, i)))
	{
		swap(A[i], A[j]);
		i = j;
	}
	return i;
}
// 建堆算法 [0, n)
// O(n)
void heapify(int* A, int n)
{
	int last_internal = (n - 2) >> 1;// 最後一個內部結點，即最後一個結點的父節點
	for (int i = last_internal; i >= 0; i--)
		// 下濾
		percolateDown(A, n, i);
}
void heapSort(int* A, int n)
{
	// 首先構建最大堆
	heapify(A, n);
	while (--n)
	{
		swap(A[0], A[n]);
		percolateDown(A, n, 0);
	}
}

六、快速排序

算法思路： 快速排序也使用了分治的策略，但與歸併排序不同的是，快速排序選擇一個軸點pivot作爲分割點，左邊的數都比pivot小，右邊的數都比pivot大。

// 劃分算法，選擇一個軸點，對區間[lo, hi]進行劃分
int partition(int* A, int lo, int hi)
{
	// 隨機選取一個元素作爲pivot，防止劃分不當
	swap(A[lo], A[lo + rand() % (hi - lo + 1)]);
	int pivot = A[lo];
	while (lo < hi)
	{
		while (lo < hi)
		{
			if (pivot < A[hi])
				hi--;
			else
			{
				A[lo++] = A[hi]; break;
			}
		}
		while (lo < hi)
			if (pivot > A[lo])
				lo++;
			else
			{
				A[hi--] = A[lo]; break;
			}
	}
	A[lo] = pivot;
	return lo;
}
// 對[start, end)排序
void quickSort(int* A, int start, int end)
{
	if (end - start < 2) return; // 單區間
	int mi = partition(A, start, end - 1); // 在[start, end-1]區間內構造軸點
	quickSort(A, start, mi);
	quickSort(A, mi + 1, end);
}