[算法] 十个经典排序算法

 动图演示参考：https://www.cnblogs.com/onepixel/articles/7674659.html

基数排序参考：https://blog.csdn.net/double_happiness/article/details/72452243

1、常见的排序算法

2、算法分析

3、算法的实现

1）排序类

#ifndef _SORT_H_
#define _SORT_H_

#include<vector>

class Sort {
public:
    //交换排序：冒泡和快排
    void bubbleSort(std::vector<int> &nums);
    void quickSort(std::vector<int> &nums, int left, int right);
    
    //插入排序：简单插入和希尔排序
    void insertSort(std::vector<int>&nums);
    void shellSort(std::vector<int>&nums);
    
    //选择排序：简单选择排序和堆排序
    void selectSort(std::vector<int>&nums);
    void heapSort(std::vector<int>&nums);

    //归并排序：二路归并和多路归并
    void mergeSort2(std::vector<int>&,int,int);

    //计数排序
    void countingSort(std::vector<int>&);
    //桶排序——计数排序的进阶版
    void bucketSort(std::vector<int>&);
    //基数排序
    void RadixSort(std::vector<int>&nums);
private:
    void swap_ele(int &a, int &b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
};

#endif // !_SORT_H_

2）排序算法的具体实现

/**
* 冒泡排序是一种简单的排序算法。
* 它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
* 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
* 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
* 时间复杂度n*n
* 稳定性：稳定
*/
void Sort::bubbleSort(std::vector<int>&nums) {
    for (int i = 0; i < nums.size() - 1; ++i) {
        for (int j = 0; j < nums.size() - 1 - i; ++j) {
            if (nums[j] > nums[j + 1])
                swap_ele(nums[j], nums[j + 1]);
        }
    }
}

/**
* 快速排序
* 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，
* 则可分别对这两部分记录继续进行排序，以达到整个序列有序。
* 利用了分治的思想
* 时间复杂度 n*logn
* 稳定性：不稳定
*/
void Sort::quickSort(std::vector<int> &nums, int left, int right) {
    if (left >= right)
        return;
    int i = left, j = right;
    int base = nums[left];
    while (i < j) {
        while (i<j&&nums[j]>=base)//注意等号
            --j;
        if (i < j)
            nums[i] = nums[j];
        while (i < j&&nums[i] <= base)//注意等号
            ++i;
        if (i < j)
            nums[j] = nums[i];
    }
    nums[i] = base;
    quickSort(nums, left, i - 1);
    quickSort(nums, i + 1, right);
}

/**
* 插入排序
* 从第一个元素开始，该元素可以认为已经被排序；
* 取出下一个元素，在已经排序的元素序列中从后向前扫描；
* 如果该元素（已排序）大于新元素，将该元素移到下一位置；
* 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
* 将新元素插入到该位置后；
* 重复步骤2~5。
* 时间复杂度n*n
* 稳定性：稳定
*/
void Sort::insertSort(std::vector<int>&nums) {
    int tmp,pos;
    for (int i = 1; i < nums.size(); ++i) {
        tmp = nums[i];
        pos = i - 1;
        while (pos >= 0 && nums[pos] > tmp) {
            nums[pos + 1] = nums[pos];
            --pos;
        }
        nums[pos + 1] = tmp;
    }
}

/**
* 希尔排序
* 希尔排序又叫做缩小增量排序，首先选择一个增量increment，比较距离差为increment的元素，对他们进行简单插入排序
* 然后缩小增量，直到计算增量为1的情况
* 增量的选择对排序的效果至关重要，希尔提出的是increment/2向下取整，直到incremtn==1，Knuth提出取increment/3+1，直到为1
* 我们选用的是Knuth的方法
* 时间复杂度低于n*n
* 稳定性：有的稳定有的不稳定——不稳定
*/
void Sort::shellSort(std::vector<int>&nums) {
    int n = nums.size();
    if (n < 2)return;
    int increment = n / 3 + 1;
    int tmp,i,j;
    while (increment > 0) {
        for ( i = increment; i < n; ++i) {
            tmp = nums[i];
            for (j = i - increment; j >= 0 && nums[j] > tmp; j -= increment) {//简单插入排序
                nums[j + increment] = nums[j];
            }
            nums[j + increment] = tmp;
        }
        //更新increment
        if (increment == 1)break;//已经计算过1的情况，全部都有顺序了
        increment = increment / 3 + 1;
    }
}

/**
* 简单选择排序
* 分成两部分：已经排序序列和未排序序列，前者初始为空；
* 通过扫描，找到为排序序列中的最大或者最小元素，放到未排序序列的起始位置，也是已经排序序列的末尾位置
* 时间复杂度为n*n
* 稳定性：不稳定
*/
void Sort::selectSort(std::vector<int>&nums) {
    int Min, min_pos;
    int n = nums.size();
    for (int i = 0; i < n - 1; ++i) {
        Min = nums[i];
        min_pos = i;
        for (int j = i + 1; j < n ; ++j) {
            if (nums[j] < Min) {
                Min = nums[j];
                min_pos = j;
            }
        }
        nums[min_pos] = nums[i];
        nums[i] = Min;
    }
}

/**
* 堆排序
* 利用堆的特性，父节点一定比子节点大（小），这样每次取出根节点，就是最大（小）的
* 时间复杂度：对于n个节点的堆，对每个元素执行pop()操作，时间复杂度是n*logn
* 稳定性：不稳定
*/
void Sort::heapSort(std::vector<int>&nums) {
    //首先堆化
    std::make_heap(nums.begin(), nums.end());
    //然后进行排序——排序中用到了pop_heap
    std::sort_heap(nums.begin(), nums.end());
}

/**
* 2路归并排序
* 采用分治的思想，不断把序列划分成两部分，分别对两部分进行排序
* 然后把两部分合并成一个完整的有序序列
* 时间复杂度：n*logn ？？如何计算
* 稳定性：稳定
*/
void Sort::mergeSort2(std::vector<int>&nums, int start, int end) {
    std::vector<int> tmp_v;
    if (start < end) {
        int mid = start + (end - start) / 2;
        mergeSort2(nums, start, mid);
        mergeSort2(nums, mid + 1, end);
        //将结果合并到tmp_v数组中
        int i = start, j = mid + 1;
        while (i <= mid||j <= end) {
            if (i > mid||(j<=end&& nums[i] > nums[j])) {//注意j的界限的判断
                tmp_v.push_back(nums[j++]);
            }
            else if (j > end || (i<=mid&&nums[j] >= nums[i])) {//注意等号，这里就决定了归并排序是稳定的
                tmp_v.push_back(nums[i++]);
            }
        }
        //从tmp_v拷贝回nums
        for (i = start; i <= end; ++i) {
            nums[i] = tmp_v[i - start];
        }
    }
}

/**
* 计数排序
* 找出数组nums中最大的数K，建立辅助数组V，V的长度是K+1
* 遍历nums，统计nums[i]的出现次数，并填入V[nums[i]]中
* 遍历V，用V的下标i填充nums，直到V[i]为0
* 计数排序具有一定的局限性，首先只能针对整数，并且在最大值不算太大并且序列比较集中的时候效率很高
* 最好的时间复杂度n+K，最坏的时间复杂度n+K，平均时间复杂度：n+K
* 额外空间复杂度：K，K为最大值
* 稳定性：稳定
*/
void Sort::countingSort(std::vector<int>&nums) {
    int n = nums.size();
    if (n < 2)return;
    int Max = nums[0];
    int i;
    for (i = 1; i < n; ++i) {
        if (nums[i] > Max)
            Max = nums[i];
    }
    std::vector<int>V(Max + 1, 0);
    for (i = 0; i < n; ++i) {
        ++V[nums[i]];
    }
    int idx = 0;
    for (i = 0; i < V.size(); ++i) {
        while (V[i] > 0) {
            nums[idx++] = i;
            --V[i];
        }
    }
}

/**
* 桶排序——计数排序的进阶版
* 思想是将数组nums中的元素通过映射函数分到数量有限的桶里
* 然后再使用其他的排序算法把每个桶里的数据进行排序
* 最后把各个桶中的记录列出来即可得到有序序列
* 桶排序的效率取决于两方面：一是桶的数目尽可能大；二是映射函数尽量能够使n个数据平均分配
* 可以发现，计数排序就是桶排序的特殊情况，桶的数目最大，并且每个桶中只有一个数据的情况
* 最好的时间复杂度：有n个桶的时候，每个桶都只有一个元素，不用排序，时间复杂度为n
* 最坏的时间复杂度：只有1个桶，这取决于采用的排序方法，时间复杂度是n*n或者n*logn
* 平均时间复杂度：假设有k个桶，时间复杂度是n+k 
* 额外的空间复杂度n
* 稳定性：取决于单个桶中采用的排序算法
*/
void Sort::bucketSort(std::vector<int>&nums) {
    int n = nums.size();
    if (n < 2)return;
    int Default_Size = 5;
    int Max=nums[0], Min=nums[0];
    int i;
    for (i = 1; i < n; ++i) {
        if (nums[i] > Max)
            Max = nums[i];
        if (nums[i] < Min)
            Min = nums[i];
    }
    int BucketNum = (Max - Min) / Default_Size + 1;
    std::vector<std::vector<int>>buckets(BucketNum);

    for (i = 0; i < n; ++i) {
        //映射函数采用(nums[i]-Min)/Default_Size
        buckets[(nums[i] - Min) / Default_Size].push_back(nums[i]);
    }
    //对每个桶中的元素进行快速排序
    int j;
    for (j = 0; j < buckets.size(); ++j) {
        if(buckets[j].size()>1)
            quickSort(buckets[j],0,buckets[j].size()-1);//这里采用的方法决定了桶排序是不是稳定的
    }
    //按照顺序取出元素
    int idx = 0;
    for (j = 0; j < buckets.size(); ++j) {
        for (i = 0; i < buckets[j].size(); ++i)
            nums[idx++] = buckets[j][i];
    }
}

/**
* 基数排序
* 把nums中所有的数的位数看成是相同长度的
* 从个位开始比较各个数的大小
* 统计出每位出现的次数，然后根据次数计算出起始位置
* 根据起始位置，把nums[i]映射到bucket中
* 用bucket的结果覆盖nums，计算更高位
* 时间复杂度 n
* 额外的空间 n
* 稳定性：稳定
*/

void Sort::RadixSort(std::vector<int>&nums) {
    int n = nums.size();
    if (n < 2)return;
    int Max = nums[0];
    int i;
    for (i = 0; i < n; ++i) {
        if (nums[i] > Max)
            Max = nums[i];
    }
    std::vector<int>pos(10,0);
    std::vector<int>bucket(n+1);//桶用来记录一次排序后的结果
    int exp = 1,idx=0;
    while (Max /exp) {
        for (i = 0; i < n; ++i) {
            ++pos[(nums[i] / exp) % 10];//pos[i]用来记录每一位出现的次数
        }
        for (i = 1; i < 10; ++i) {
            pos[i] += pos[i - 1];//这个时候pos[i]记录的是 当前位是i的数字 在桶中的起始位置，注意是起始位置
        }
        for (i = 0; i < n; ++i) {//给nums[i]重新排序
            idx = (nums[i] / exp) % 10;
            bucket[pos[idx]++] = nums[i];
            //这一步是关键
            //pos[idx]代表当前这一位的数字是idx的起始位置，每次用完起始位置之后，要向后移动
            //这也决定了基数排序是稳定的
        }
        for (i = 1; i <= n; ++i) {
            nums[i-1] = bucket[i];//重新给nums赋值
        }
        if (INT_MAX / exp < 10) {//exp已经到了整数极限
            break;
        }
        exp *= 10;//计算更高位
        for (i = 0; i < 10; ++i) {
            pos[i] = 0;//还原pos
        }
    }
}

3）排序算法的调用

template <typename T>
void printVector(std::vector<T>nums) {
    for (int i = 0; i < nums.size(); ++i) {
        std::cout << nums[i] << " ";
    }
    std::cout << std::endl;
}
int main()
{
    Sort mysort;
    std::vector<int> nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::vector<int> res;
    std::cout << "冒泡排序前：";
    printVector(nums);
    std::cout << "冒泡排序后：";
    mysort.bubbleSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums= { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "快速排序前：";
    printVector(nums);
    std::cout << "快速排序后：";
    mysort.quickSort(nums,0,nums.size()-1);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "插入排序前：";
    printVector(nums);
    std::cout << "插入排序后：";
    mysort.insertSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "希尔排序前：";
    printVector(nums);
    std::cout << "希尔排序后：";
    mysort.shellSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "简单选择排序前：";
    printVector(nums);
    std::cout << "简单选择排序后：";
    mysort.selectSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "堆排序前：";
    printVector(nums);
    std::cout << "堆排序后：";
    mysort.heapSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "2路归并排序前：";
    printVector(nums);
    std::cout << "2路归并排序后：";
    mysort.mergeSort2(nums,0,nums.size()-1);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "计数排序前：";
    printVector(nums);
    std::cout << "计数排序后：";
    mysort.countingSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "桶排序前：";
    printVector(nums);
    std::cout << "桶排序后：";
    mysort.bucketSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    nums = { 9,4,23,67,234,6,3,2,7,43,2134,643,23 };
    std::cout << "基数排序前：";
    printVector(nums);
    std::cout << "基数排序后：";
    mysort.bucketSort(nums);
    printVector(nums);
    std::cout << "---------------------------------" << std::endl;

    return 0;
}

4）结果