内部排序算法总结(上)【C++实现】

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;
}

下篇在这里:

内部排序算法总结(下)【C++实现】

  • 3
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SinHao22

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值