LeetCode912-排序数组

HDLaZy

已于 2022-07-27 10:08:31 修改

阅读量1k

点赞数

分类专栏：算法题文章标签：算法

于 2022-03-30 20:31:14 首次发布

本文链接：https://blog.csdn.net/hd_cash/article/details/123849556

版权

算法题专栏收录该内容

33 篇文章 0 订阅

订阅专栏

方式1：直接插入排序

class Solution {
    public int[] sortArray(int[] nums) {

            if(nums==null){
                return nums;
            }

            for(int i=1;i<nums.length;i++){
                int j=i-1;
                int temp=nums[i];
                for(;j>=0;j--){
                    if(nums[j]>temp){
                        nums[j+1]=nums[j];
                    }else{
                        break;
                    }
                }
                nums[j+1]=temp;
            }

            return nums;

    }
}

方式2：希尔排序

class Solution {
    public int[] sortArray(int[] nums) {

            int gap=nums.length;
            while(gap>1){
                gap=gap/2;
                shell(nums,gap);
            }
            shell(nums,1);

            return nums;

    }


    public static void shell(int [] nums  ,  int gap){

            for(int i=gap;i<nums.length;i++){

                int j=i-gap;
                int temp=nums[i];

                for(;j>=0;j-=gap){
                    if(nums[j]>temp){
                        nums[j+gap]=nums[j];
                    }else{
                        break;
                    }
                }

                nums[j+gap]=temp;
            }

    }

}

方式3：选择排序

过不了LeetCode，因为时间超过限制。

class Solution {
    public int[] sortArray(int[] nums) {
            for(int i=0;i<nums.length;i++){
                int j=i+1;
                int minIndex=i;
                for(;j<nums.length;j++){
                    if(nums[j]<nums[minIndex]){
                        minIndex=j;
                    }
                }
                swap(nums,i,minIndex);
            }
            return nums;

    }

    public static void swap(int [] nums, int i,int minIndex){
        int temp=nums[i];
        nums[i]=nums[minIndex];
        nums[minIndex]=temp;
    }

}

方式4：堆排序

从小到大的顺序需要建立最大堆

class Solution {
    public int[] sortArray(int[] nums) {

            if(nums==null){
                return nums;
            }

            create(nums);

            int end=nums.length-1;

            while(end>0){
                int temp=nums[0];
                nums[0]=nums[end];
                nums[end]=temp;
                shift(nums,0,end);
                end--;
            }

            return nums;


    }

    public static void create(int []  nums){
            int parent=(nums.length-1-1)/2;
            for(;parent>=0;parent--){
                shift(nums,parent,nums.length);
            }
    }

    public static void shift(int [] nums,int parent ,int len){

            //左孩子
            int child=parent*2+1;
           

            while(child<len){
                 if(child+1<len&&nums[child+1]>nums[child]){
                child++;
            }
            if(nums[child]>nums[parent]){
                int temp=nums[child];
                nums[child]=nums[parent];
                nums[parent]=temp;
                parent=child;
                child=parent*2+1;
            }else{
                break;
            }
            }
    }

}

方式5：冒泡排序

class Solution {
    public int[] sortArray(int[] nums) {

        boolean flag=false;
        int temp=0;
        
      for(int i=0;i<nums.length-1;i++){
          flag=false;
          for(int j=0;j<nums.length-1-i;j++){
              if(nums[j]>nums[j+1]){
                  temp=nums[j];
                  nums[j]=nums[j+1];
                  nums[j+1]=temp;
                  flag=true;
              }
          }
          if(flag=false){
              break;
          }
      }

      return nums;
    }

}

方式6：快速排序

递归实现：

class Solution {
    public int[] sortArray(int[] nums) {

            quick(nums,0,nums.length-1);

            return nums;
     
    }

    public void quick(int []  nums, int s, int e){

        if(s>=e){
            return;
        }

        int mid=part(nums,s,e);

        quick(nums,s,mid-1);
        quick(nums,mid+1,e);

    }

    public int  part(int[] nums,int s, int e){

            int temp=nums[s];

            while(s<e){
                
                while(s<e && nums[e]>=temp){
                    e--;
                }

                nums[s]=nums[e];

                while(s<e && nums[s]<=temp){
                    s++;
                }
                
                nums[e]=nums[s];

            }

            nums[e]=temp;

            return e;

    }

}

非递归方式：

class Solution {
    public int[] sortArray(int[] nums) {

           Stack<Integer>stack=new Stack<>();

            int s=0;
            int e=nums.length-1;

            int mid=part(nums,s,e);

            if(s+1<mid){
                stack.push(s);
                stack.push(mid-1);
            }

            if(e-1>mid){
                stack.push(mid+1);
                stack.push(e);
            }

            while(!stack.isEmpty()){

                e=stack.pop();
                s=stack.pop();
                mid=part(nums,s,e);


                 if(s+1<mid){
                stack.push(s);
                stack.push(mid-1);
            }

            if(e-1>mid){
                stack.push(mid+1);
                stack.push(e);
            }

            }

            return nums;
    }



    public int  part(int[] nums,int s, int e){

            int temp=nums[s];

            while(s<e){
                
                while(s<e && nums[e]>=temp){
                    e--;
                }

                nums[s]=nums[e];

                while(s<e && nums[s]<=temp){
                    s++;
                }
                
                nums[e]=nums[s];

            }

            nums[e]=temp;

            return e;

    }

}

方式7：归并排序

递归方式：

class Solution {
    public int[] sortArray(int[] nums) {
            magerFunc(nums,0,nums.length-1);
            return nums;
    }

    public static void  magerFunc(int [] nums, int low , int high){

            if(low>=high){
                return;
            }

            int mid=(low + high) >>> 1;
            
            magerFunc(nums,low,mid);
            magerFunc(nums,mid+1,high);

            marge(nums,low,high,mid);

    }

    public static void marge(int[] nums, int low, int high, int mid){

            int[] temp=new int[high-low+1];
            int k=0;
            int s1=low;
            int e1=mid;
            int s2=mid+1;
            int e2=high;

            while(s1<=e1 && s2<=e2){
                if(nums[s1]<=nums[s2]){
                    temp[k++]=nums[s1++];
                }else{
                    temp[k++]=nums[s2++];
                }
            }

            while(s1<=e1){
                temp[k++]=nums[s1++];
            }

            while(s2<=e2){
                temp[k++]=nums[s2++];
            }

            for(int i=0;i<k;i++){
                nums[low+i]=temp[i];
            }


    }

}

非递归：

class Solution {
    public int[] sortArray(int[] nums) {
     

     int gap=1;

        while(gap<nums.length){
            

                for(int i=0;i<nums.length;i+=2*gap){
                    
                    int low=i;
                    int mid=low+gap-1;
                    if(mid>=nums.length){
                        mid=nums.length-1;
                    }
                    int high=mid+gap;
                    if(high>=nums.length){
                        high=nums.length-1;
                    }

                    marge(nums,low,high,mid);
                }

                gap=2*gap;


        }

        return nums;

   
    }

    public static void marge(int[] nums, int low, int high, int mid){

            int[] temp=new int[high-low+1];
            int k=0;
            int s1=low;
            int e1=mid;
            int s2=mid+1;
            int e2=high;

            while(s1<=e1 && s2<=e2){
                if(nums[s1]<=nums[s2]){
                    temp[k++]=nums[s1++];
                }else{
                    temp[k++]=nums[s2++];
                }
            }

            while(s1<=e1){
                temp[k++]=nums[s1++];
            }

            while(s2<=e2){
                temp[k++]=nums[s2++];
            }

            for(int i=0;i<k;i++){
                nums[low+i]=temp[i];
            }


    }

}