排序算法问题

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

代码如下：

1.插入排序(简单插入排序、直接插入排序)

//算法思想；从当前位置开始，从后往前找比数字小的，找到后插入到这个小的数字后面
//再找的过程中，如果发现一个比当前数字大，同时将这个数字往后移动
//时间复杂度：O(n^2)  空间复杂度O(1) 稳定性:稳定，没有跳跃式的交换数据 
//直接插入排序的特点：越有序越快；完全有序能达到O(n);
class Solution {
public:
    void InsertSort(vector<int>& nums,int n)
    {
        for(int i=0;i
        {
            int temp = nums[i];//记录未排序数组的下标
            int j = i-1;//记录已经排序数组的下标
            while(j >= 0 && nums[j] >temp) 
            {
                nums[j+1] = nums[j];//当已经排序好的数组数字大于未排序的数组数字，将已经排序好的数字向后移一个
                j--;
            }
            nums[j+1] = temp;//如果未排序的数组数字大于已经排序好的数字，直接插入到排序好的数字后面
        }
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        InsertSort(nums,n);
        return nums;
    }
};

2.希尔排序

//直接插入排序越有序越快是希尔排序的一个理论基础
//算法描述：1.间隔式的分组 2.利用直接插入排序让组内有序 3.缩小分组再次排序 4.再次调用直接插入排序  ...直到缩为一组完全有序
//时间复杂度：O(n^1.3-n^1.5)   空间复杂度：O(1)  稳定性：不稳定
class Solution {
public:
    void ShellSort(vector<int>& nums,int n)
    {
        int gap=n;
        while(gap>1)//间隔式分组，每一组利用直接插入排序，让组内有序
        {
            gap/=2;//每次分组都在上一组的基础上折半
            for(int i=gap;i
            {
                int temp = nums[i];
                int j = i-gap;
                while(j >= 0 && nums[j] >temp) 
                {
                    nums[j+gap] = nums[j];
                    j-=gap;
                }
            nums[j+gap] = temp;
            }
        }
        
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        ShellSort(nums,n);
        return nums;
    }
};

3.冒泡排序

代码如下：

 
//两两比较，大的往后走
//时间复杂度：O(n^2) 空间复杂度：O(1)  稳定性：稳定
class Solution {
public:
    void BubbleSort(vector<int>& nums,int n)
    {
        for(int i=0;i-1;i++)//走的趟数
        {
            for(int j=0;j-1;j++)//每走一遍，最大的数字在最后面，走的次数越多，越往后面的数字排序越正确
            {
                if(nums[j]>nums[j+1])//两两交换，较大的数字在后面
                {
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
 
                }
            }
        }
       
        
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        BubbleSort(nums,n);
        return nums;
    }
};

4.快速排序

代码如下：

//算法描述：先在数据中找到一个基准，从后往前找比基准小的数字，找到后往前挪动
//从前往后找比基准大的数字，找到往后挪动  重复之前的动作
//一次划分的时间复杂度：O(n) 划分logn次
//时间复杂度：O(nlogn)  空间复杂度：O(logn)(递归的次数)
//快排的缺点：空间复杂度大，不稳定
//快排最大缺点：越有序越慢，完全有序，为O(n^2)退化为选择排序
class Solution {
public:
    void QuickSort(vector<int>& nums,int left,int right)
    {
        if(left>=right)//只有一个数或区间不存在
        {
            return;
        }
        int i=left,j=right;//i在最左边，j在最右边
        int base=nums[left];//定义最左边的数字为基准
        while(i
        {
            while(nums[j]>=base&&i//从后往前找比这个比准数字小的
            {
                j--;
            }
            while(nums[i]<=base&&i//从前往后找比这个基准数字大的
            {
                i++;
            }
            swap(nums[i],nums[j]);//找到之后交换两个数字
        }
        nums[left]=nums[i];//当i=j时，将基准数字与nums[i]交换
        nums[i]=base;
        //在一次完成之后，左边的数字都比基准数字小，右边的数字都比基准数字大
        QuickSort(nums,left,i-1);//递归左边
        QuickSort(nums,i+1,right);//递归右边
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        QuickSort(nums,0,n-1);
        return nums;
    }
};

5.选择排序

代码如下：

//算法描述：每次都从待排序中找到最小值和待排序的第一个交换
//时间复杂度：O(n^2) 空间复杂度：O(1)  稳定性：不稳定
class Solution {
public:
    void SelectSort(vector<int>& nums,int n)
    {
        int minIndex;
        for(int i=0;i-1;i++)
        {
            minIndex=i;
            for(int j=i+1;j
            {
                if(nums[minIndex]>nums[j])
                {
                    minIndex=j;
                }
                
            }
            swap(nums[i],nums[minIndex]);
        }
        
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        SelectSort(nums,n);
        return nums;
    }
};