数据结构的学习历程07

优先级队列

二叉树的顺序存储

把一颗完全二叉树按照层序遍历的顺序存在数组中，则有：
假设当前下标为i：
则i下标节点的
父亲节点是：(i-1)/2
左孩子节点是：i2+1
右孩子节点是：i2+2

堆

堆的作用时找到一组数据中的最大值/最小值
大堆：根节点的值比根节点所在这棵树的所有节点的值都大，就叫大堆，也叫大根堆，或最大堆。反之就叫做小堆，小根堆，最小堆。
大堆（小堆）的所有子树都为大堆（小堆）。
调整一颗二叉树成为大堆或小堆时，应该先调整它的子树，当其所有子树都为大堆或小堆时，再进行最后的调整
堆在逻辑上时一颗完全二叉树，实际是保存在数组中的
在堆排序中的时间复杂度为O(n)
下图为一颗二叉树变为大堆时，调整过程：

而在入堆时，把节点加在最后一个节点之后，然后进行调整，此时只需调整所有包含此节点的二叉树。如：上图中若在val值为6的节点的左孩子节点加一个节点，则需要调整val为(6，19，98)的这三颗二叉树。
在出堆时，若需要出第一个节点，则应把第一个节点与最后一个节点的位置互换，然后再出掉最后一个节点之后再进行调整。如图，若需要出堆98，则交换98与4，在把堆中 val为4，28的节点进行调整。
TOPK问题，就是找一组数据中最大(小)的K个数据，如果找最大，则用小堆，如果找最小，则用大堆。

PriorityQueue

实例化：

PriorityQueue<Integer> que = new PriorityQueue<>();
默认为小堆：
PriorityQueue que = new PriorityQueue<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1-o2;
    }
});
此时定义为小堆
PriorityQueue que = new PriorityQueue<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
});
此时定义为大堆
也可定义堆的大小
PriorityQueue que = new PriorityQueue<>(5,new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
});
此时是大小为5的大堆

在PriorityQueue中：如果定义的是大堆，那么在存入元素的时候就会自动将最大数调整到根节点，反之，最小数调整到根节点。

TOP-K问题

TOP-K问题：就是找出一组数据最大(小)的K个数字，如果找最大，则用小堆，如果找最小，则用大堆。如：找K个最大的数据，就建立一个大小为K 的小堆，先入这组数据的前K个数字，每次都与PriorityQueue的队首元素去比较，如果比较结果是数据比队首元素大，则出掉队首，比较的这个数字进队。遍历完成后，PriorityQueue里面的元素就是要求的所有元素

找出最大的K个数字

	public static int[] topK(int[] array,int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k,
                new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        for (int i = 0; i < array.length; i++) {
            if(k > 0) {
                minHeap.offer(array[i]);
                k--;
            }else {
               Integer val = minHeap.peek();
               if(array[i] > val) {
                   minHeap.poll();
                   minHeap.offer(array[i]);
                }
            }
        }
        int[] ret = new int[minHeap.size()];
        for(int i = 0;i<minHeap.size();i++){
        	ret[i] = minHeap.poll();
        }
        return ret;

找出和最小的K对数字

	//此处并没有按照TOPK问题的思路去解
    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        PriorityQueue<List<Integer>> que = new PriorityQueue<>(new Comparator<List<Integer>>() {
            @Override
            public int compare(List<Integer> o1, List<Integer> o2) {
                return (o1.get(0)+o1.get(1))-(o2.get(0)+o2.get(1));
            }
        });
        List<List<Integer>> ret = new ArrayList<>();
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                List<Integer> tmp= new ArrayList<>();
                tmp.add(nums1[i]);
                tmp.add(nums2[j]);
                ret.add(tmp);
            }
        }
        if (k>nums1.length*nums2.length) return ret;
        for (int i = 0;i<ret.size();i++){
            que.offer(ret.get(i));
        }
        ret.clear();
        for (;k>0;k--) {
            ret.add(que.poll());
        }
        return ret;
    }