每日一题：Leetcode-912 手撕堆排序

力扣题目

解题思路

java代码

力扣题目：

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

解题思路：

算法原理：

• 快速排序：通过选择一个基准元素，将数组分为两部分，小于基准的在左边，大于基准的在右边，然后对两部分分别递归进行排序。
• 堆排序：先将数组构建成一个最大堆，然后不断取出堆顶元素并调整堆，实现排序。

思路：

• 在快速排序中，通过一趟排序将基准元素放到正确位置，并对左右子区间递归处理。
• 在堆排序中，先构建堆，然后每次交换堆顶和末尾元素，再对剩余元素进行堆调整。

代码实现：

• 快速排序部分：选择一个基准元素，通过两个指针从两端向中间移动进行交换，找到基准元素的正确位置，然后递归处理左右子区间。
• 堆排序部分：先构建最大堆，然后通过交换和调整堆来逐步排序。

时间复杂度：

• 快速排序：平均情况和最好情况为O（nlogn） ，最坏情况为 O（n²）。
• 堆排序：O（nlogn）。

空间复杂度：

• 快速排序：主要是递归调用栈空间，平均情况为O（logn） 。
• 堆排序：O（1）。

java代码：

package org.example.mouth8;

public class Leetcode912_1 {
    public static void main(String[] args) {
        Leetcode912_1 leetcode912_1 = new Leetcode912_1();
        int[] ints = leetcode912_1.sortArray1(new int[]{5, 2, 3, 1});

        for (int anInt : ints) {
            System.out.println(anInt);
        }
    }
    // 快排
    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    public void quickSort(int[] nums, int l, int r) {
        if (l < r) {
            int pivot = nums[l];
            int i = l;
            int j = r;

            while (i < j) {
                while (i < j && nums[j] >= pivot) {
                    j--;
                }
                nums[i] = nums[j];

                while (i < j && nums[i] < pivot) {
                    i++;
                }
                nums[j] = nums[i];
            }
            nums[i] = pivot;
            quickSort(nums, l, i - 1);
            quickSort(nums, i + 1, r);
        }
    }

    // 堆排序
    public int[] sortArray1(int[] nums) {
        int len = nums.length;
        for (int i = len / 2 - 1; i >= 0; i--) {
            heapify(nums, len, i);
        }
        for (int i = len - 1; i >= 0; i--) {
            int temp = nums[0];
            nums[0] = nums[i];
            nums[i] = temp;
            heapify(nums, i, 0);
        }
        return nums;
    }

    public void heapify(int[] nums, int len, int i) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;
        if (left < len && nums[left] > nums[largest]) {
            largest = left;
        }
        if (right < len && nums[right] > nums[largest]) {
            largest = right;
        }
        if (largest!= i) {
            int temp = nums[i];
            nums[i] = nums[largest];
            nums[largest] = temp;
        }
    }
}

更多详细内容同步到公众号，感谢大家的支持！

每天都会给刷算法的小伙伴推送明日一题，并且没有任何收费项