牛客网编程高频题2——排序

目录

排序

题目描述

示例一

输入

返回值

示例2

输入

返回值

备注:

方法一：快速排序

方法二：堆排序

方法三：归并排序

---

排序

题目描述

给定一个数组，请你编写一个函数，返回该数组排序后的形式。

示例一

输入

[5,2,3,1,4]

返回值

[1,2,3,4,5]

示例2

输入

[5,1,6,2,5]

返回值

[1,2,5,5,6]

备注:

数组的长度不大于100000，数组中每个数的绝对值不超过10^9

方法一：快速排序

import java.util.*;

public class Solution {
    public int[] MySort (int[] arr) {
        // write code here
        arr=QuickSort(arr,0,arr.length-1);
        return arr;
    }
    
    public static int[] QuickSort(int[] arr,int low,int high){
        if(low<high){
            int curpos=Partition(arr,low,high);
            QuickSort(arr,low,curpos-1);
            QuickSort(arr,curpos+1,high);
        }
        return arr;
    }

    public static int Partition(int[] arr,int low,int high){
        int curPos=low;
        int curVal=arr[low];
        for (int i = low+1; i <= high; i++) {
            if(arr[i]<curVal){
                curPos++;//循环结束之后可以找到当前元素在数组中的下标
                if(curPos!=i){//将处于右边小于当前元素的数交换到左边
                    int temp=arr[curPos];
                    arr[curPos]=arr[i];
                    arr[i]=temp;
                }
            }
        }
        arr[low]=arr[curPos];//将当前元素放置到应位置
        arr[curPos]=curVal;
        return curPos;
    }
}

快排的时间和空间复杂度还是可以的

方法二：堆排序

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        arr=heapSort(arr);
        return arr;
    }
    
    //堆排序
    public static int[] heapSort(int[] arr) {
        for (int i = arr.length/2-1; i >= 0; i--) {
            adjustHeap(arr,i,arr.length);
        }

        for (int j = arr.length-1; j >0 ; j--) {
            swap(arr,0,j);
            adjustHeap(arr,0,j);
        }
        return arr;
    }

    //调整堆：arr 待组堆, i 起始结点, length 堆的长度
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp=arr[i];
        for (int k = 2*i+1; k < length; k=2*k+1) {
            if(k+1<length && arr[k]<arr[k+1]){
                k++;
            }
            if(arr[k]>temp){
                swap(arr,k,i);
                i=k;
            }else{
                break;
            }
        }
    }
    
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

堆排序的时间复杂度更好一点

方法三：归并排序

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        arr=MergeSort(arr);
        return arr;
    }
    
    public static int[] MergeSort(int[] arr){
        int[] res=new int[arr.length];
        mergeSort(arr,res,0,arr.length-1);
        return arr;
    }



    public static void mergeSort(int[] arr,int[] res,int low,int high){
        if(low>=high){
            return;
        }else{
            int mid=(low+high)/2;
            mergeSort(arr,res,low,mid);
            mergeSort(arr,res,mid+1,high);
            merge(arr,res,low,mid,high);
        }
    }

    public static void merge(int[] arr,int[] res,int low,int mid,int high){
        for (int i = low; i <= high; i++) {
            res[i]=arr[i];
        }
        int i=low;
        int j=mid+1;
        int k=low;
        while(i<=mid && j<=high) {
            if(res[i]>res[j]){
                arr[k++]=res[j++];
            }else{
                arr[k++]=res[i++];
            }
        }
        while(i<=mid){
            arr[k++]=res[i++];
        }
        while(j<=high){
            arr[k++]=res[j++];
        }
    }
}

 和堆排序差不多，但是略差点

综合看来，感觉还是堆排序性能更优！