算法 堆排序

堆排序利用完全二叉树特点构建大/小顶堆，全程在数组上完成，没有额外的空间消耗。

堆排序一般情况下在速度上相比快速排序和归并排序这种分治类型排序没有优势。但是当处理大数据量的Top问题时，非常适用。

java中的实现PriorityQueue 优先级队列是小根堆结构，但是可以通过comparator自定义大小，转换成大根堆模式。

PriorityQueue(int initialCapacity,Comparator<? super E> comparator)

节点与其子节点关系

大根堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  

小根堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] 

//降序排序 构建大根堆
 public class HeapSort implements IArraySort {
 
     @Override
     public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

         int len = arr.length;

        //构建大根堆
        buildMaxHeap(arr, len);

        for (int i = len - 1; i > 0; i--) {
            //每次将顶部最大元素 移到堆尾
            swap(arr, 0, i);
            //堆长度减一
            len--;
            //再次调整剩余堆 找出最大根
            heapify(arr, 0, len);
        }
        return arr;
    }

    private void buildMaxHeap(int[] arr, int len) {
        //从最后一个节点(len-1) 的 父节点(floor(len / 2))  开始倒推
        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
            heapify(arr, i, len);
        }
    }

    //堆的 i节点 调整
    private void heapify(int[] arr, int i, int len) {
        int left = 2 * i + 1;  //左子节点位置
        int right = 2 * i + 2; //右子节点位置
        int largest = i;       //记录最大节点位置

        if (left < len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            swap(arr, i, largest);
            //交换后 再次向下比较调整 直到到满足大根堆堆条件位置
            heapify(arr, largest, len);
        }
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

TOP K 问题思路

https://www.cnblogs.com/en-heng/p/6336625.html

求最大K个采用小根堆，而求最小K个采用大根堆。

  求最大K个的步奏：

1.     根据数据前K个建立K个节点的小根堆。
2.     在后面的N-K的数据的遍历

• 如果数据大于小根堆的根节点，则根节点的值覆为该数据，并调节节点至小根堆。
• 如果数据小于或等于小根堆的根节点，小根堆无变化。

• public int findKthLargest(int[] nums, int k) {
    //java优先级队列小顶堆结构
    PriorityQueue<Integer> minQueue = new PriorityQueue<>(k); 
    for (int num : nums) {
      if (minQueue.size() < k || num > minQueue.peek())
        minQueue.offer(num);
      if (minQueue.size() > k)
        minQueue.poll();
    }
    return minQueue.peek();
  }