基础的排序算法

排序

测试网址

选择排序

class Solution {
public:
    // 选择排序：选择对应的下标的元素进行交换
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        if(n<1) return {};
        for(int i=0;i<n-1;i++)
        {
            int minIndex=i;     //这一轮排序最小的数字的坐标
            int minNum=nums[0]; //记录这一轮最小的数字
            for(int j=i+1;j<n;j++)
            {
                minIndex=nums[j]<=nums[minIndex]?j:minIndex;
                minNum=nums[minIndex];
            }
            int temp=nums[i];
            nums[i]=nums[minIndex];
            nums[minIndex]=temp;
        }
        return nums;
    }
};

超时了但是还是说明能排序的

插入排序

class Solution {
public:
    //插入排序
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        if(n<1) return{};
        for(int i=1;i<n;i++)
        {
            int temp=nums[i];//存储要插入的数
            int j=i-1;          //从要插入的数的前一个数开始，如果大就把数组往后移
            for(;j>=0&&temp<nums[j];j--)
            {
                nums[j+1]=nums[j];
            }
            nums[j+1]=temp;         //对应位置把数字插进去
        }
        return nums;
    }
};

超时了，但是前面的排序是对的

希尔排序

class Solution {
public:
    //希尔排序
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        if(n<1) return {};
        for(int inc=n;inc>0;inc=inc/2)    //每次排序的间距
        {
            for(int i=inc;i<n;i++)  //分组进行插入排序
            {
                int j=i;
                int temp=nums[i];   //存储要插入的数
                for(;j>=inc&&temp<nums[j-inc];j=j-inc)
                {
                    nums[j]=nums[j-inc];
                }
                nums[j]=temp;
            }
        }
        return nums;
    }
};

执行用时：76 ms, 在所有 C++ 提交中击败了51.65%的用户

内存消耗：27.8 MB, 在所有 C++ 提交中击败了48.87%的用户

归并排序

class Solution {
public:
    
    void Merge(vector<int>& nums,vector<int>& tempArr,int start,int mid,int end){
        int left=start;         //左边数组的第一个坐标
        int right=mid+1;        //第二个数组的第一个坐标
        int index=start;        //存储附属数组的坐标
        while(left<=mid&&right<=end)
        {   
            if(nums[left]<nums[right])
                tempArr[index++]=nums[left++];
            else
                tempArr[index++]=nums[right++];
        }
        while(left<=mid)
            tempArr[index++]=nums[left++];
        while(right<=end)  
            tempArr[index++]=nums[right++];
        for(int i=start;i<=end;i++)
            nums[i]=tempArr[i];
    }

    void MergeSort(vector<int>& nums,vector<int>& tempArr,int start,int end)
    {
        if(start>=end) return;
        int mid=(start+end)/2;
        MergeSort(nums,tempArr,start,mid);
        MergeSort(nums,tempArr,mid+1,end);
        Merge(nums,tempArr,start,mid,end);

    }
    //归并排序入口
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        if(n<0) return {};
        vector<int> tempArr(n,0);//辅助数组
       MergeSort(nums,tempArr,0,n-1);       
        return nums;
    }
};

执行用时：64 ms, 在所有 C++ 提交中击败了73.51%的用户

内存消耗：28.4 MB, 在所有 C++ 提交中击败了23.13%的用户

快速排序

class Solution {
public:
    int getFlag(vector<int>& nums,int left,int right)
    {
        int flagVal=nums[left];
        int l=left;
        int r=right;
        while(l<r)
        {
            while(l<r&&nums[r]>=flagVal)
            {
                r--;
            }
            if(l<r)
            {
                nums[l]=nums[r];                     
            }
            
            while(l<r&&nums[l]<flagVal)
            {
                l++;
            }
            if(l<r)
            {
                nums[r]=nums[l];              
            }          
        }
        nums[l]=flagVal;
        return l;
    }

    void QuickSort(vector<int>& nums,int left,int right)
    {
        if(left>=right) return;
        int flagIndex=getFlag(nums,left,right);
        QuickSort(nums,left,flagIndex-1);
        QuickSort(nums,flagIndex+1,right);

    }
    vector<int> sortArray(vector<int>& nums) {
        QuickSort(nums,0,nums.size()-1);
        return nums;
    }
    
};

堆排序

class Solution {
public:
    //调整堆，堆中共有n个元素，i为节点的下表
    void heapify(vector<int>& arr,int n,int i)
    {
        int largest=i;      //假设最大值为i
        int lson=i*2+1;     //左孩子的下标（下标从零开始）
        int rson=i*2+2;     //右孩子的下标
        if(lson<n&&arr[largest]<arr[lson])  //最大值比左孩子小就令最大值下标等于左孩子下标
            largest=lson;
        if(rson<n&&arr[largest]<arr[rson])  //最大值比右孩子小就令最大值下标等于右孩子下标
            largest=rson;
        if(largest!=i)                      //取mmx(当前值 左孩子值 右孩子值)作为当前堆堆顶
        {
            int temp=arr[i];
            arr[i]=arr[largest];
            arr[largest]=temp;
            heapify(arr,n,largest);         //重新被调换的元素形成的堆
        }
    }
    void heapSort(vector<int>& arr,int n)
    {
        int i;
        for(i=n/2-1;i>=0;i--)               //从第一个有子节点的元素开始建立堆
            heapify(arr,n,i);
        for(i=n-1;i>0;i--)                  //不断把第一个元素和最后一个元素交换并调整为最大堆
        {
            int temp=arr[i];
            arr[i]=arr[0];
            arr[0]=temp;
            heapify(arr,i,0);
        }
    }
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        heapSort(nums,n);
        return nums;
    }
};