下图为几个常见算法的特点总结:
下面为用C++实现的排序算法:
#include<iostream>
#include<vector>
#include<algorithm>
#include<iterator>
using namespace std;
// 冒泡排序
// A:数组 n:元素个数
// 时间复杂度:O(n^2)
// 稳定性:稳定
void BubbleSort(vector<int> &A, const int &n) {
for (int i = 0; i<n; i++) {
//bool flag = true;
for (int j = n - 1; j>i; j--) {
//flag = false;
if (A[j]<A[j - 1]) {
swap(A[j], A[j - 1]);
//flag = true;
}
}
}
}
// 简单选择排序
// 时间复杂度:O(n^2)
// 空间复杂度:O(1)
// 稳定性:不稳定
void SelectionSort(vector<int> &A, const int &n) {
for (int i = 0; i<n-1; i++) {
int min = i;
for (int j = i + 1; j<n; j++) {
if (A[j]<A[min]) min = j;
}
if (min != i) swap(A[i], A[min]);
}
}
// 直接插入排序
// 时间复杂度:O(n^2)
// 空间复杂度:O(1)
// 稳定性:稳定
void InsertionSort(vector<int> &A, const int &n) {
for (int i = 1; i<n; i++) {
int key = A[i];
int j = i - 1;
while (j >= 0 && key<A[j]) {
A[j + 1] = A[j];
j--;
}
A[j + 1] = key;
}
}
// 希尔排序:
// A:数组 d:分组间距 n:元素个数
// 时间复杂度:O(n^1.5)
// 空间复杂度:O(1)
// 稳定性:不稳定
void ShellSort(vector<int> &A, int d, const int &n) {
int i, j, key;
while (d > 0) {
for (i = d; i < n; i++) {
key = A[i];
for (j = i - d; j >= 0; j -= d) {
if (key < A[j]) {
A[j + d] = A[j];
}
else {
break;
}
}
A[j + d] = key;
}
d -= 2; //最终要保证d为1
}
}
// 堆排
// 时间复杂度:O(nlogn)
// 空间复杂度:O(1)
// 稳定性:不稳定
// 不适合在元素个数太少的情况
void AdjustHeap(vector<int> &A, int n) {
int i, j;
for (i = (n - 1) / 2; i > 0; i--) { //(n-1)/2:最后一个有孩子节点的编号
j = 2 * i; //左孩子
if (j + 1 <= n - 1) { //左右孩子都有
if (A[j + 1] > A[j]) { //选取左右孩子中较大的
j = j + 1;
}
}
//******************************************
// 交换--较大的元素调整到根节点
// 在此也可以用a[0]当作中间变量来交换
// 相当于temp,因为a[0]在整个排序过程中
// 没有使用
//******************************************
if (A[i] < A[j]) {
swap(A[i], A[j]);
}
}
}
// 调用AdjustHeap进行堆排
void HeapSort(vector<int> &A, int n) {
for (int i = 0; i < n - 1; i++) {
AdjustHeap(A, n - i);
swap(A[1], A[n - 1 - i]);
}
}
// 归并排序
// 时间复杂度:O(nlogn)
// 空间复杂度:O(n)
// 稳定性:稳定
void Merge(vector<int> &arr, vector<int> ®, const int start, const int end) {
if (start >= end)return;
int len = end - start, mid = (len >> 1) + start;
//分成两部分
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
//然后合并
Merge(arr, reg, start1, end1);
Merge(arr, reg, start2, end2);
int k = start;
//两个序列一一比较,哪的序列的元素小就放进reg序列里面,然后位置+1再与另一个序列原来位置的元素比较
//如此反复,可以把两个有序的序列合并成一个有序的序列
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
//然后这里是分情况,如果arr2序列的已经全部都放进reg序列了然后跳出了循环
//那就表示arr序列还有更大的元素(一个或多个)没有放进reg序列,所以这一步就是接着放
while (start1 <= end1)
reg[k++] = arr[start1++];
//这一步和上面一样
while (start2 <= end2)
reg[k++] = arr[start2++];
//把已经有序的reg序列放回arr序列中
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
void MergeSort(vector<int> &arr, const int len) {
//创建一个同样长度的序列,用于临时存放
vector<int> reg(len);
Merge(arr, reg, 0, len - 1);
}
// 快速排序(改进版--避免了交换支点的开销)
// 时间复杂度:O(nlogn)
// 空间复杂度:O(nlogn)
// 稳定性:不稳定
void QuickSort(vector<int> &A, int low, int high) {
int i = low;
int j = high;
if (i < j) {
int pivot = A[i]; //保存支点
while (i < j) { //i == j跳出循环
//支点为i
while (i < j && pivot <= A[j]) {
j--;
}
if (i < j) {
A[i] = A[j];
i++;
}
//支点为j
while (i < j && A[i] <= pivot) {
i++;
}
if (i < j) {
A[j] = A[i];
j--;
}
}
A[i] = pivot; //i==j时填入支点
QuickSort(A, low, i - 1);
QuickSort(A, i + 1, high);
}
}
// 测试用例
int main() {
vector<int> arr = { 9, 8, 7, 6, 5, 4, 4, 4, 6, 6, 6 };
vector<int> temp(arr.size());
//vector<int> arr = {0, 9, 8, 7, 6, 5, 4, 4, 4, 6, 6, 6}; //heap sort test
//BubbleSort(arr,arr.size());
//SelectionSort(arr,arr.size());
//InsertionSort(arr,arr.size());
//ShellSort(arr, 5, arr.size());
//HeapSort(arr,arr.size());
//copy(arr.begin() + 1, arr.end(), ostream_iterator<int>(cout, " ")); //heap sort test
//MergeSort(arr,arr.size());
QuickSort(arr, 0, arr.size()-1);
copy(arr.begin(), arr.end(), ostream_iterator<int>(cout, " "));
cout << endl;
return 0;
}