七种常见排序算法的C++实现

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u013146882/article/details/59518053

下图为几个常见算法的特点总结:


下面为用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> &reg, 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;
}


阅读更多
换一批

没有更多推荐了,返回首页