内部排序算法总结（上）C++实现

Posted 2021-05-25 Rainbowman 0

CONTENT

• 0. 前言
• 1. 基于交换的排序
• • 1.1 冒泡排序
  • 1.2 快速排序
• 2. 基于插入的排序
• • 2.1 简单插入排序
  • 2.2 希尔排序

0. 前言

该系列更多的是为了方便以后快速复习，所以只总结排序算法的思想、动画演示、代码和时间复杂度。

更详细的内容可看这篇博客，本篇中的图片和一些内容出自该博客。参考博客

排序算法种类

各排序算法时间复杂度

1. 基于交换的排序

1.1 冒泡排序

（1） 思想

冒泡排序有三种写法：

（1）一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位；

（2）经过优化的写法：使用一个变量记录当前轮次的比较是否发生过交换，如果没有发生交换表示已经有序，不再继续排序；

（3）进一步优化的写法：除了使用变量记录当前轮次是否发生交换外，再使用一个变量记录上次发生交换的位置（第一次该位置为结尾，之后每轮该位置前移一个），下一轮排序时到达上次交换的位置就停止比较。

（2） 时间复杂度

平均时间复杂度	最好	最坏
O(n2)	O(n)	O(n2)

（3） 动画演示

（4） 代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void bubbleSort(vector<int>& nums)
{
    int i, j = nums.size() - 1;
    while(j>=0){
        for(i=0; i<j; i++){
            if(nums[i]>nums[i+1])   swap(nums[i], nums[i+1]);
        }
        j--;
    }
}

int main()
{
    int n;
    vector<int> nums;
    while(cin>>n){
        nums.push_back(n);
    }
    bubbleSort(nums);
    for(int num : nums){
        cout<<num<<" ";
    }
    return 0;
}

1.2 快速排序

（1） 思想

（1）从数组中取出一个数，称之为基数（pivot）；

（2）遍历数组，将比基数大的数字放到它的右边，比基数小的数字放到它的左边。遍历完成后，数组被分成了左右两个区域；

（3）将左右两个区域视为两个数组，重复前两个步骤，直到排序完成（递归）。

（2） 时间复杂度

平均时间复杂度	最好	最坏
O(nlog(n))	O(nlog(n))	O(n2)

（3） 动画演示
动画出处

（4） 代码

动画是从最右边的元素开始，而代码是从最左边的元素开始的，都一样。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void quickSort(vector<int>& nums, int left, int right)
{
    if(left>=right)  return;
    int i = left, j = right;
    while(j>i){
        while(nums[j]>=nums[left] && j>i)  j--;
        while(nums[i]<=nums[left]&& j>i)  i++;
        if(j>i) swap(nums[i], nums[j]);
    }
    int pivot = j;
    swap(nums[left], nums[pivot]);
    quickSort(nums, left, pivot-1);
    quickSort(nums, pivot+1, right);
}

int main()
{
    int n;
    vector<int> nums;
    while(cin>>n){
        nums.push_back(n);
    }
    quickSort(nums, 0, nums.size()-1);
    for(int num : nums){
        cout<<num<<" ";
    }

    return 0;
}

2. 基于插入的排序

2.1 简单插入排序

（1） 思想

（1）从第一个元素开始，该元素可以认为已经被排序；

（2）取出下一个元素的key，在已经排序的元素序列中从后向前扫描；

（3）如果扫描到的元素（已排序）大于新元素key，将扫描到的元素移到下一位置；

（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

（5）将新元素插入到该位置后；

（6）从接下来的n-1个元素开始重复步骤2~5。

（2） 时间复杂度

平均时间复杂度	最好	最坏
O(n2)	O(n)	O(n2)

（3） 动画演示

（4） 代码

#include <iostream>
#include <vector>

using namespace std;

void insertSort(vector<int>& nums)
{
    if(nums.empty())  return;
    int i, j;
    for(i=1; i<nums.size(); i++){
        int temp = nums[i];
        for(j=i-1; j>=0; j--){
            if(nums[j]>temp){
                nums[j+1] = nums[j];
            }
            else{
                break;
            }
        }
        nums[j+1] = temp;
    }
}

int main()
{
    int n;
    vector<int> nums;
    while(cin>>n){
        nums.push_back(n);
    }
    insertSort(nums);
    for(int num : nums){
        cout<<num<<" ";
    }
}

2.2 希尔排序

（1） 思想

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，这样可以让一个元素可以一次性地朝最终位置前进一大步，然后算法再取越来越小的步长进行排序。仅增量因子为1时，整个序列作为一个记录序列来处理，即最后一步进行普通的插入排序后，序列有序。

（2） 时间复杂度

平均时间复杂度	最好	最坏
O(nlog(n))	O(nlog2(n))	O(nlog2(n))

（3） 动画演示

（4） 代码

#include <iostream>
#include <vector>

using namespace std;

void shellSort(vector<int>& nums)
{
    int gap = nums.size()/2;
    int i, j;
    while(gap){
        for(i=gap; i<nums.size(); i++){
            int temp = nums[i];
            for(j=i-gap; j>=0; j-=gap){
                if(nums[j]>temp)  nums[j+gap] = nums[j];
                else break;
            }
            nums[j+gap] = temp;
        }
        gap = gap/2;
    }
}

int main()
{
    int n;
    vector<int> nums;
    while(cin>>n){
        nums.push_back(n);
    }
    shellSort(nums);
    for(int num : nums){
        cout<<num<<" ";
    }
    return 0;
}