您现在的位置是：首页 >技术杂谈 >LeetCode排序数组（常用排序一一实现）网站首页技术杂谈

912. 排序数组 - 力扣（LeetCode）

这道题他会设置一个数据量特别特别大的案例，对于一般的算法是一定过不去的

1.冒泡排序---这种的时间复杂度是O(n*n)，对于这道题是不可能过得去的

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortArray(int* nums, int numsSize, int* returnSize)
{
    //冒泡
    for(int i=0;i<numsSize;i++)
    {
        for(int j=0;j<numsSize-i-1;j++)
        {
            //小到大
            if(nums[j]>nums[j+1])
            {
                int tem=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=tem;
            }
        }
    }
    *returnSize=numsSize;
    return nums;

}

2.选择排序---时间复杂的是O(n*n),也是不能过得去的

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortArray(int* nums, int numsSize, int* returnSize)
{
    //选择排序，遍历数组找到最小的数位置记录下来，然后与第i位进行交换
    *returnSize=numsSize;
    for(int i=0;i<numsSize;i++)
    {
        int n=i;//记录最小的元素的下角标
        for(int j=i+1;j<numsSize;j++)
        {
            if(nums[j]<nums[n])
            {
                n=j;
            }
        }
        //将第n位与第i为进行交换
        int tem=nums[n];
        nums[n]=nums[i];
        nums[i]=tem;
    }
    return nums;
}

 3.插入排序---时间复杂度O(n*n),也是不能过的去的

int* sortArray(int* nums, int numsSize, int* returnSize)
{
    //插入排序：在已经排好序的数组中进行插入
    *returnSize=numsSize;
    for(int i=0;i<numsSize;i++)
    {
        //从此位置向前比
        for(int j=i;j>0;j--)
        {
            if(nums[j]<nums[j-1])
            {
                int tem=nums[j];
                nums[j]=nums[j-1];
                nums[j-1]=tem;
            }
            else
            break;
        }
    }
    return nums;
}

4.希尔排序---插入排序的进阶,时间复杂度O(n^1.3),可以实现

int* sortArray(int* nums, int numsSize, int* returnSize)
{
    //希尔排序---插入排序的进阶，可以减少查找次数，移动次数减少
    *returnSize=numsSize;
    int i,j,inc,key;
    for(inc=numsSize/2;inc>0;inc/=2)
    //inc表示每次分组中元素的个数，直到为0的时候才停止
    {
        for(i=inc;i<numsSize;i++)//从inc位置开始，后面的每一个都要进行排序
        {
            //key=nums[i];//记录这个位置的值
            for(j=i;j>=inc&&nums[j]<nums[j-inc];j-=inc)//每次比较的时候都要用组与组之间进行对比，并且我们比较的值不能比第一组的值更靠前
            //而且我们是从尾向前开始比较的
            {
                //nums[j]=nums[j-inc];//每次向前走一组的位置
                key=nums[j];
                nums[j]=nums[j-inc];
                nums[j-inc]=key;
            }
            //nums[j]=key;
        }
    }
    return nums;
}

5.快排---时间复杂度O(nlogn)

快排第一次移动的必须是右边的角标，因为现在我们是以左边的为比较的对象，所以开始的时候必须是右边的角标先动

 void quicksort(int* nums,int left,int right)
 {
     if(left>=right)
     return;
     else
     {
         int mem_left=left;
         int mem_right=right;//分别记录左角标，右角标
         int com=nums[left];
         int flag=1;//0移动左角标，1移动右角标
         while(left<right)
         {
             if(flag==0)
             {
                 //左角标动
                 if(nums[left]<=com)
                 {
                     left++;
                 }
                 else
                 {
                    //换位
                    nums[right]=nums[left];
                    right--;
                    flag=1;
                 }
             }
             else
             {
                 //右角标动
                 if(nums[right]>=com)
                 {
                     right--;
                 }
                 else
                 {
                     //换位
                     nums[left]=nums[right];
                     left++;
                     flag=0;
                 }
             }
         }
         nums[left]=com;
         quicksort(nums,mem_left,left-1);
         quicksort(nums,left+1,mem_right);
     }
 }
 int* sortArray(int* nums, int numsSize, int* returnSize)
 {
     //快排
     *returnSize=numsSize;
     int left=0;
     int right=numsSize-1;
     quicksort(nums,left,right);
     return nums;
 }

我们的快排还是无法通过本题----因为我们每次排序选取的比较对象是首元素没有随机性，需要改进

 void quicksort(int* nums,int left,int right)
 {
     if(left>=right)
     return;
     else
     {
         int mem_left=left;
         int mem_right=right;//分别记录左角标，右角标
         int tem=rand()%(right-left+1)+left;
         //交换两个位置的值到最左边
         int com=nums[tem];
         nums[tem]=nums[left];
         nums[left]=com;
         int flag=1;//0移动左角标，1移动右角标
         while(left<right)
         {
             if(flag==0)
             {
                 //左角标动
                 if(nums[left]<=com)
                 {
                     left++;
                 }
                 else
                 {
                    //换位
                    nums[right]=nums[left];
                    right--;
                    flag=1;
                 }
             }
             else
             {
                 //右角标动
                 if(nums[right]>=com)
                 {
                     right--;
                 }
                 else
                 {
                     //换位
                     nums[left]=nums[right];
                     left++;
                     flag=0;
                 }
             }
         }
         nums[left]=com;
         quicksort(nums,mem_left,left-1);
         quicksort(nums,left+1,mem_right);
     }
 }
 int* sortArray(int* nums, int numsSize, int* returnSize)
 {
     //快排
     //生成随机种子
     srand((unsigned int)time(NULL));
     *returnSize=numsSize;
     int left=0;
     int right=numsSize-1;
     quicksort(nums,left,right);
     return nums;
 }