一、冒泡排序
算法思路: 从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
)
=
2
T
(
n
/
2
)
+
O
(
n
)
=
O
(
n
l
o
g
n
)
T(n) = 2T(n/2) + O(n) = O(n log 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);
}