排序算法 C++

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

1、代码 

#include <iostream>
#include <vector>
using namespace std;
//冒泡排序
void bubble_sort(vector<int> &nums)
{
    for (int i = 0; i < nums.size() - 1; i++) { // times
        for (int j = 0; j < nums.size() - i - 1; j++) { // position
            if (nums[j] > nums[j + 1]) {
                swap(nums[j],nums[j + 1]);
            }
        }
    }
}
//插入排序
void insert_sort(vector<int> &nums)
{
    for (int i = 1; i < nums.size(); i++) { // position
        for (int j = i; j > 0; j--) {
            if (nums[j] < nums[j - 1]) {
                swap(nums[j],nums[j - 1]);
            }
        }
    }
}
//选择排序
void selection_sort(vector<int> &nums)
{
    for (int i = 0; i < nums.size(); i++) { // position
        int min = i;
        for (int j = i + 1; j < nums.size(); j++) {
            if (nums[j] < nums[min]) {
                min = j;
            }
        }
        swap(nums[i], nums[min]);
    }
}
//希尔排序
void shell_sort(vector<int> &nums)
{
    for (int gap = nums.size() / 2; gap > 0; gap /= 2)
        for (int i = gap; i < nums.size(); i++)
            for (int j = i - gap; j >= 0 && nums[j] > nums[j + gap]; j -= gap)
                swap(nums[j], nums[j + gap]);
}

void merge(vector<int> &data, int start, int mid, int end) {
    vector<int> tmp;
    int i = start, j = mid + 1;
    while (i != mid + 1 && j != end + 1) {
        if (data[i] <= data[j]) {
            tmp.push_back(data[i++]);
        } else {
            tmp.push_back(data[j++]);
        }
    }
    while (i != mid + 1) {
        tmp.push_back(data[i++]);
    }
    while (j != end + 1) {
        tmp.push_back(data[j++]);
    }
    for (int i = 0; i < tmp.size(); i++) {
        data[start + i] = tmp[i];
    }
}
//归并排序
void merge_sort(vector<int> &data, int start, int end) {
    if (start < end) {
        int mid = (start + end) / 2;
        merge_sort(data, start, mid);
        merge_sort(data, mid + 1, end);
        merge(data, start, mid, end);
    }
}

int partition(vector<int>& nums, int low, int high)
{
    int pivotkey;
    pivotkey = nums[low];
    while(low < high)
    {
        while(low < high && nums[high] >= pivotkey)
            high--;
        swap(nums[low], nums[high]);
        while(low < high && nums[low] <= pivotkey)
            low++;
        swap(nums[low], nums[high]);
    }
    return low;
}
//快速排序
void quick_sort(vector<int> &nums, int low, int high)
{
    int pivot;
    if(low < high)
    {
        pivot = partition(nums, low, high);
        quick_sort(nums, low, pivot-1);
        quick_sort(nums, pivot+1, high);
    }
}

void max_heapify(vector<int> &nums, int beg, int end)
{
    int curr = beg;
    int child = curr * 2 + 1;
    while (child < end) {
        if (child + 1 < end && nums[child] < nums[child + 1]) {
            child++;
        }
        if (nums[curr] < nums[child]) {
            int temp = nums[curr];
            nums[curr] = nums[child];
            nums[child] = temp;
            curr = child;
            child = 2 * curr + 1;
        } else {
            break;
        }
    }
}
//堆排序
void heap_sort(vector<int> &nums)
{
    int n = nums.size();
    for (int i = n / 2 - 1; i >= 0; i--) { // build max heap
        max_heapify(nums, i, nums.size() - 1);
    }

    for (int i = n - 1; i > 0; i--) { // heap sort
        swap(nums[0],nums[i]);
        max_heapify(nums, 0, i);
    }
}

int main(void){
  int tmp[5] = {5,4,3,2,1};
  vector<int> num(tmp, tmp+5);
//  bubble_sort(num);
//  insert_sort(num);
//  selection_sort(num);
//  shell_sort(num);
//  merge_sort(num,0,num.size()-1);
//  quick_sort(num,0,num.size()-1);
  heap_sort(num);
  for(int i = 0; i < num.size(); ++i){
    cout << num[i] << endl;
  }
  return 0;
}

2、复杂度分析

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。