堆排序（java）

堆

堆是一种完全二叉树
大根堆：根节点比子节点值大，用于从小往大排序
小根堆：根节点比子节点小，用于从大到小排序

堆排序（java）

大根堆

/**
 *大根堆性质：完全二叉树，跟节点比子节点的值大
 * 用于从小到大排序
 *
 * 1.乱序数组构造最大堆
 *      以本题为例，构建过程为
 *      7,3,18,5,7,9,2,5 -》7,7,18,5,3,9,2,5->18,7,7,5,3,9,2,5->18,7,9,5,3,7,2,5
 * 2 取出堆顶元素，和数组末尾元素交换
 * 3 重建大根堆（0，i），取出堆顶元素arr[i]
 * 4 一直到i==0结束
 */
public class HeapSort {

    @Test
    public void test(){
        int[] arr ={7,3,18,5,7,9,2,5};
        heapSort(arr,arr.length);
    }
	public void heapSort(int[] arr, int n) {
		// 构造大小为n的大根堆
        for (int i = n / 2 -1; i >= 0; i--) {
            heapify(arr, n, i);
        }
        // 从堆顶开始取元素，取出堆顶之后重建二叉堆。
        for (int i = n - 1; i >= 0; i--) {
            swap(arr, 0, i);
            heapify(arr, i, 0);
        }
    }

    /**
     * 构造最大堆
     * @param arr
     * @param n
     * @param pos
     */
    public void heapify(int[] arr, int n, int pos) {
        int largest = pos;//将最大元素设置为堆顶元素
        int l = 2 * pos + 1;
        int r = 2 * pos + 2;
        // left 比root大
        if (l < n && arr[l] > arr[largest])
            largest = l;
        // root 比 root大
        if (r < n && arr[r] > arr[largest])
            largest = r;
        if (largest != pos) {
            //交换，
            swap(arr, pos, largest);
            heapify(arr, n, largest);
        }
    }

    private void swap(int[] arr, int i, int largest){
        int tem= arr[i];
        arr[i] = arr[largest];
        arr[largest]=tem;
    }
}

应用

求N个数中最小的K个数
剑指offer–最小的k个数

思路

1.构建大小为K的大根堆
2.k之后的元素和堆顶比较
3.若小于堆顶元素，则和堆顶交换并重建大根堆
4.输出k个元素的大根堆即可。
5输出顺序为从大到小。

实现

public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        int size =input.length;
        ArrayList<Integer> res = new ArrayList<>();
        if(k>size)
            return res;
         //构造大小为k的二叉堆
        for (int i = k / 2 -1; i >= 0; i--) {
            heapify(input, k, i);
        }
		 // 判断k~size个数是否比堆顶小，小则交换，并重建大小为k的大根堆
        for (int i =k; i <size; i++) {
            if (input[0]>input[i]) {
                swap(input, 0, i);
                heapify(input,k, 0);
            }
        }
        //输出k大小的大根堆即可。
        for(int i=0;i<k;i++)
            res.add(input[i]);
        return res;
    }
     /**
     * 构造最大堆
     * @param arr
     * @param n
     * @param pos
     */
    public void heapify(int[] arr, int n, int pos) {
        int largest = pos;//将最大元素设置为堆顶元素
        int l = 2 * pos + 1;
        int r = 2 * pos + 2;
        // left 比root大
        if (l < n && arr[l] > arr[largest])
            largest = l;
        // root 比 root大
        if (r < n && arr[r] > arr[largest])
            largest = r;
        if (largest != pos) {
            //交换，
            swap(arr, pos, largest);
            heapify(arr, n, largest);
        }
    }

    private void swap(int[] arr, int i, int largest){
        int tem= arr[i];
        arr[i] = arr[largest];
        arr[largest]=tem;
    }