堆排序 && Kth Largest Element in an Array

堆排序

堆节点的访问

通常堆是通过一维数组来实现的。在数组起始位置为0的情形中：

父节点i的左子节点在位置(2*i+1);

父节点i的右子节点在位置(2*i+2);

子节点i的父节点在位置floor((i-1)/2);

堆的操作

在堆的数据结构中，堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。堆中定义以下几种操作：

最大堆调整（Max_Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点

创建最大堆（Build_Max_Heap）：将堆所有数据重新排序。从最后一个父节点开始调用“最大堆调整”，直到第一个父节点（根节点）

堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

Java

 package test;

 public class Solution {

     private void maxHeapify(int[] nums, int index, int heapSize) {
         int iMax, iLeft, iRight;
         while(true) {
             iMax = index;
             iLeft = 2 * index + 1;
             iRight = 2 * index + 2;

             if (iLeft < heapSize && nums[iMax] < nums[iLeft]) {
                 iMax = iLeft;
             }
             if (iRight < heapSize && nums[iMax] < nums[iRight]) {
                 iMax = iRight;
             }

             if(iMax != index) {
                 int tmp = nums[iMax];
                 nums[iMax] = nums[index];
                 nums[index] = tmp;
                 index = iMax;
             } else {
                 break;
             }
         }
     }

     private void buildMaxHeap(int[] nums) {
         int lastParent = (int) Math.floor((nums.length-1) / 2);
         for(int i=lastParent; i>=0; i--) {
             maxHeapify(nums, i, nums.length);
         }
     }

     public void heapSort(int[] nums) {
         buildMaxHeap(nums);

         for(int i=nums.length-1; i>=0; i--) {
             int tmp = nums[0];
             nums[0] = nums[i];
             nums[i] = tmp;
             maxHeapify(nums, 0, i);
         }
     }

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         int[] nums = {3,5,2,1,0,9,4,5,6,7,3,2,6};
         Solution s = new Solution();
         s.heapSort(nums);
         for(int num: nums) {
             System.out.print(num + " ");
         }
     }

 }

参考

https://zh.wikipedia.org/wiki/堆排序

http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/

Kth Largest Element in an Array

来源：https://leetcode.com/problems/kth-largest-element-in-an-array

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note: 
You may assume k is always valid, 1 ≤ k ≤ array's length.

利用堆排序思想，创建最大堆，重复“移除位在第一个数据的根节点，并做最大堆调整的递归运算”这一步骤，第K次移除的根节点就是数据中第K大的元素。

也可利用快速排序的思想，见http://www.cnblogs.com/renzongxian/p/7465453.html

Java

 class Solution {
     private void maxHeapify(int[] nums, int index, int heapSize) {
         int iMax, iLeft, iRight;
         while(true) {
             iMax = index;
             iLeft = 2 * index + 1;
             iRight = 2 * index + 2;
             if(iLeft < heapSize && nums[iMax] < nums[iLeft]) {
                 iMax = iLeft;
             }
             if(iRight < heapSize && nums[iMax] < nums[iRight]) {
                 iMax = iRight;
             }

             if(iMax != index) {
                 int tmp = nums[iMax];
                 nums[iMax] = nums[index];
                 nums[index] = tmp;
                 index = iMax;
             } else {
                 break;
             }
         }
     }

     private void buildMaxHeap(int[] nums) {
         int lastParent = (int)Math.floor((nums.length-1) / 2);
         for(int i=lastParent; i>=0; i--) {
             maxHeapify(nums, i, nums.length);
         }
     }

     public int findKthLargest(int[] nums, int k) {
         buildMaxHeap(nums);
         for(int i=nums.length-1; i>=nums.length-k; i--) {
             int tmp = nums[0];
             nums[0] = nums[i];
             nums[i] = tmp;
             maxHeapify(nums, 0, i);
         }
         return nums[nums.length-k];
     }
 } // 7 ms