堆排序的一些思考

堆排序

经典应用： leecode：前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]
说明：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。

package com.leecode.pratice;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * @Author: wzc
 * @Poject: AlgorithmStudy
 */
public class Practice {
    //利用api
    public List<Integer> heapSortK(int[] nums,int k){
        List<Integer> result=new ArrayList<>();
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }
        //PriorityQueue是天然小根堆，利用compare，转化为大根堆
        PriorityQueue<Integer> queue=new PriorityQueue<>((a,b)->a-b);
        map.forEach((key,value)->{
            queue.offer(key);
            if (queue.size() > k)
                queue.poll();
        });
        for (int i = 0; i < k; i++) {
            if (!queue.isEmpty()) {
                result.add(queue.poll());
            }
        }
        return result;
    }


    //利用数组构建大根堆
    public List<Integer> heapSortSelf(int[] arr, int k){
        List<Integer> result = new ArrayList<>();
        if(arr==null || arr.length==0 || arr.length<k){
            return result;
        }
        for(int i=k/2-1; i>=0; i--){
            adjustHeap(arr, i, k-1);
        }
        for(int i=k; i<arr.length; i++){
            if(arr[i] < arr[0]){
                swap(arr,0,i);
                adjustHeap(arr, 0, k-1);
            }
        }
        for(int i=0; i<k; i++){
            result.add(arr[i]);
        }
        return result;
    }
    public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public void adjustHeap(int[] nums, int position, int length){
        int temp = nums[position];
        int child = 2*position+1;
        for(; child<=length; child=child*2+1){
            if(child<length && nums[child]<nums[child+1]){
                child++;
            }
            if(temp>nums[child]){
                break;
            }
            nums[position] = nums[child];
            position = child;
        }
        nums[position] = temp;
    }

    @Test
    public void testSort() {
        int[] ints = new int[]{1, 2, 5, 24, 34};
        List<Integer> result=heapSortSelf(ints,3);
        result.stream().forEach(System.out::println);
    }
}