leetcode--912--排序数组

最新推荐文章于 2024-07-02 11:37:24 发布

原创最新推荐文章于 2024-07-02 11:37:24 发布 · 214 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

8 篇文章

订阅专栏

这篇博客探讨了四种不同的排序算法：直接插入排序、冒泡排序、快速排序和直接选择排序，它们在处理整数数组时的表现。文章通过具体示例展示了每种算法的实现，并指出这些基本排序算法在数组规模较大时可能会导致超时问题。快速排序作为其中的一种高效算法，被详细阐述并给出了实现代码。

给你一个整数数组 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 <= nums.length <= 50000
-50000 <= nums[i] <= 50000

来源：力扣（LeetCode）
链接：leetcode–912–排序数组
代码：
使用vector的sort函数

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
       
        sort(nums.begin(),nums.end());
        return nums;
    }
};

自己写的排序代码
自接插入排序：（超时）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        InsertSort(nums,n);
   
         return nums;
        
    }
    void InsertSort(vector<int>&nums,int n)//直接插入排序
    {
        int i,j;
        for( i=0;i<n;i++)
        {
            int temp=nums[i];
            for( j=i-1;j>=0&&nums[j]>temp;j--)//递增排序
            {
                nums[j+1]=nums[j];
            }
            nums[j+1]=temp;
        }
    }
};

冒泡排序：（超时）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        BubbleSort(nums,n);
   
         return nums;
        
    }
    void BubbleSort(vector<int>&nums,int n)//冒泡排序
    {
        for(int i=0;i<n-1;i++)//关键在于循环n-1次
        {
            for(int j=0;j<n-i-1;j++)//关键在于循环n-i-1
            {
                int temp;
                if(nums[j]>nums[j+1])
                {
                    temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
    }
};

快速排序：

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
       
       int n=nums.size();
       QuitSort(nums,0,n,n);
        return nums;
    }
    void QuitSort(vector<int>& nums,int low,int high,int n)
{
    if(low<high)
    {
        int pivotpos=partition(nums,low,high);
        QuitSort(nums,low,pivotpos-1,n);
        QuitSort(nums,pivotpos+1,high,n);
    }
}
int partition(vector<int>& nums,int low,int high)
{
    int pivot=nums[low];

    while(low<high)
    {
        while(low<high&&pivot>=nums[low])//关键>=
        {
            low++;
        }
        nums[high]=nums[low];

        while(low<high&&pivot<=nums[high])//关键<=
        {
            high--;
        }
        nums[low]=nums[high];


    }
    nums[low]=pivot;
    return low;
}
};

直接选择排序：（超时）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
       
       int n=nums.size();
       SelectSort(nums,n);
        return nums;
    }
   void SelectSort(vector<int>& nums,int n)
   {
     int i,j;
       for( i=0;i<n-1;i++)
       {  
           int min=i;
           for( j=i+1;j<n;j++)
           {
               if(nums[min]>nums[j])
               {
                   min=j;
               }
           }
           if(nums[min]!=nums[i])
           {
            int temp;
           temp=nums[min];
          nums[min] =nums[i];
           nums[i]=temp;
           }
         

       }
   }
};