堆排序 && 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