排序算法-快排归并堆排序-高频题-912. 排序数组

Posted 2022-04-20 hequnwang10

一、题目描述

给你一个整数数组 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]

二、解题

快速排序

快速排序在选取划分点的时候如果都是选取第一个数，那么在一种情况下[5,4,3,2,1]，排序起来非常慢，所以选取一个随机数这样可以减少这种最坏情况的发生。

class Solution 
    public int[] sortArray(int[] nums) 
        //快速排序
        int left = 0,right = nums.length-1;
        quicksort(nums,left,right);
        return nums;

    
    public void quicksort(int[] nums,int left,int right)
        if(left <= right)
            int par = randomizedPartition(nums,left,right);
            quicksort(nums,left,par-1);
            quicksort(nums,par+1,right);
        
    

    public int randomizedPartition(int[] nums, int left, int right) 
        int index = new Random().nextInt(right - left + 1) + left; // 随机选一个作为我们的主元
        swap(nums, left, index);
        return partition(nums, left, right);
    

    //划分
    public int partition(int[] nums,int left,int right)
        int pivot = nums[left];
        int j = left;
        for(int i=left+1;i<=right;i++)
            if(nums[i] < pivot)
                j++;
                swap(nums,j,i);
            
        
        swap(nums,left,j);
        return j;
    

    //交换数据
    public void swap(int[] nums,int left,int right)
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    

归并排序

class Solution 
    int[] tmp;//辅助数组
    public int[] sortArray(int[] nums) 
        //归并排序
        int len = nums.length;
        tmp = new int[len];
        mergeSort(nums, 0, nums.length - 1);
        return nums;


    
    public void mergeSort(int[] nums,int l,int r)
        if(l >= r)
            return ;
        
        int mid = l+(r - l)/2;
        mergeSort(nums,l,mid);
        mergeSort(nums,mid+1,r);
        int i = l, j = mid + 1;
        int cnt = 0;
        while (i <= mid && j <= r) 
            if (nums[i] <= nums[j]) 
                tmp[cnt++] = nums[i++];
             else 
                tmp[cnt++] = nums[j++];
            
        
        while (i <= mid) 
            tmp[cnt++] = nums[i++];
        
        while (j <= r) 
            tmp[cnt++] = nums[j++];
        
        for (int k = 0; k < r - l + 1; ++k) 
            nums[k + l] = tmp[k];
        
    

堆排序

堆排序的思想就是先将待排序的序列建成大根堆，使得每个父节点的元素大于等于它的子节点。此时整个序列最大值即为堆顶元素，我们将其与末尾元素交换，使末尾元素为最大值，然后再调整堆顶元素使得剩下的 n-1n−1 个元素仍为大根堆，再重复执行以上操作我们即能得到一个有序的序列。

class Solution 
    public int[] sortArray(int[] nums) 
        heapSort(nums);
        return nums;
    

    public void heapSort(int[] nums) 
        int len = nums.length - 1;
        buildMaxHeap(nums, len);
        for (int i = len; i >= 1; --i) 
            swap(nums, i, 0);
            len -= 1;
            maxHeapify(nums, 0, len);
        
    

    public void buildMaxHeap(int[] nums, int len) 
        for (int i = len / 2; i >= 0; --i) 
            maxHeapify(nums, i, len);
        
    

    public void maxHeapify(int[] nums, int i, int len) 
        for (; (i << 1) + 1 <= len;) 
            int lson = (i << 1) + 1;
            int rson = (i << 1) + 2;
            int large;
            if (lson <= len && nums[lson] > nums[i]) 
                large = lson;
             else 
                large = i;
            
            if (rson <= len && nums[rson] > nums[large]) 
                large = rson;
            
            if (large != i) 
                swap(nums, i, large);
                i = large;
             else 
                break;
            
        
    

    private void swap(int[] nums, int i, int j) 
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;