排序算法总结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(nlogn)$$

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);
}