NC140-排序

四款排序算法详解：快速排序、堆排序、归并排序与优先级队列应用

最新推荐文章于 2022-08-16 09:21:31 发布

原创最新推荐文章于 2022-08-16 09:21:31 发布 · 187 阅读

0 ·

CC 4.0 BY-SA版权

牛客-剑指offer 专栏收录该内容

28 篇文章

订阅专栏

本文对比分析了四种常见的排序算法：快速排序的递归实现、堆排序的高效构建、归并排序的分治策略和优先级队列的高效查找。通过实例演示，探讨了它们的时间复杂度、空间复杂度及适用场景，帮助理解不同算法间的优缺点。

在这里插入图片描述
解法1-快速排序
时间 O(nlogn) 空间O(1)
最坏为O(n2)，原因在于，当原数组本身就是正序或倒序时，每次快排之后，只是处理了一个元素，没有将其拆分为两个小数组，也就是没有起到树结构那种并行排序的作用。

public void quickSort(int[] arr, int low, int high){
        if(low>=high)
            return;
        int p = arr[low];
        int i = low;
        int j = high;
        while(i<j){
            while(j>i&&arr[j]>=p)
                j--;
            while(i<j&&arr[i]<=p)
                i++;
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
        arr[low] = arr[i];
        arr[i] = p;
        quickSort(arr,low,i-1);
        quickSort(arr,i+1,high);
    }

解法2-堆排序

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        heapSort(arr);
        return arr;
    }
    public void heapSort(int[] arr){
        if(arr.length<=1)
            return;
        for(int i = (arr.length-1)/2;i>=0;i--){
            adjust(arr,i,arr.length-1);
        }
        for(int i =arr.length-1;i>=0;i--){
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjust(arr,0,i-1);
        }
    }
    
    public void adjust(int[] arr,int low, int high){
        if(low>=high)
            return;
        int l = 2*low + 1;
        while(l<=high){
            if(l+1<=high&&arr[l+1]>arr[l])
            {
                l = l+1;
            }
            //不要忘记else
            if(arr[l]>arr[low]){
                int temp = arr[l];
                arr[l] = arr[low];
                arr[low] = temp;
                low = l;
                l = 2*low + 1;
            }
            else{
                break;
            }
        }
        
    }
}

解法三：归并排序

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        mergeSort(arr,0,arr.length-1);
        return arr;
    }
    
    public void mergeSort(int[] arr, int l,int r){
        if(l==r)
            return ;
        int mid = (l+r)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        merge(arr,l,mid,r);
    }
    public void merge(int[] arr, int l,int mid, int r){
        int[] help = new int[r-l+1];
        int i =0;
        int p = l;
        int q = mid+1;
        while(p<=mid&&q<=r){
            help[i++] = arr[p]<arr[q]?arr[p++]:arr[q++];
        }
        while(p<=mid){
            help[i++]=arr[p++];
        }
        while(q<=r)
            help[i++]=arr[q++];
        for(int k =0;k<help.length;k++)
            arr[l+k] = help[k];
    }
}

解法四：使用数据结构优先级队列

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer a,Integer b){
                return a-b;
            }
        });
        for(int i =0;i<arr.length;i++){
            pq.add(arr[i]);
        }
        for(int i =0;i<arr.length;i++){
            arr[i] = pq.poll();
        }
        return arr;
    }
}