堆和优先队列

二叉堆的实现

普通队列：先进先出，后进后出
优先队列：出入顺序与入队顺序无关；和优先级相关
玩转数据结构—慕课网波波老师

堆的基本结构：

堆中的某个节点的值总是不大于父节点的值。

索引从0开始的话：

parent(i) = (i - 1) / 2  //父节点
leftChild = 2 * i + 1 //左子节点
rightChild = 2 * i + 2 //右子节点 

自定义Array 实现：

public class Array<E> {

    private E[] data;
    private int size;

    // 构造函数，传入数组的容量capacity构造Array
    public Array(int capacity){
        data = (E[])new Object[capacity];
        size = 0;
    }

    // 无参数的构造函数，默认数组的容量capacity=10
    public Array(){
        this(10);
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    // 获取数组中的元素个数
    public int getSize(){
        return size;
    }

    // 返回数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在index索引的位置插入一个新元素e
    public void add(int index, E e){

        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");

        if(size == data.length)
            resize(2 * data.length);

        for(int i = size - 1; i >= index ; i --)
            data[i + 1] = data[i];

        data[index] = e;

        size ++;
    }

    // 向所有元素后添加一个新元素
    public void addLast(E e){
        add(size, e);
    }

    // 在所有元素前添加一个新元素
    public void addFirst(E e){
        add(0, e);
    }

    // 获取index索引位置的元素
    public E get(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        return data[index];
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        data[index] = e;
    }

    // 查找数组中是否有元素e
    public boolean contains(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e))
                return true;
        }
        return false;
    }

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e))
                return i;
        }
        return -1;
    }

    // 从数组中删除index位置的元素, 返回删除的元素
    public E remove(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed. Index is illegal.");

        E ret = data[index];
        for(int i = index + 1 ; i < size ; i ++)
            data[i - 1] = data[i];
        size --;
        data[size] = null; // loitering objects != memory leak

        if(size == data.length / 4 && data.length / 2 != 0)
            resize(data.length / 2);
        return ret;
    }

    // 从数组中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从数组中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index = find(e);
        if(index != -1)
            remove(index);
    }

    //交换元素
    public void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size) {
            throw new IllegalArgumentException("Index is Illegal.");
        }
        E e = data[i];
        data[i] = data[j];
        data[j] = e;
    }
    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++){
            res.append(data[i]);
            if(i != size - 1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }

    // 将数组空间的容量变成newCapacity大小
    private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[i];
        data = newData;
    }

    //取出第一个元素
    public E getFirst() {
        return get(0);
    }

    //取出最后一个元素
    public E getLast() {
        return get(size - 1);
    }
}

自定义堆 MaxHeap

取出最大元素：将最大元素取出后，把数组最后一个元素复制到头元素，再删去最后一个元素，在通过siftDown 操作将头元素与往下进行交换，直到满足二叉堆要求。
添加元素：将元素放在数组最后一位，然后进行siftUp 操作将元素与父节点进行比较，直到满足二叉堆要求。

public class MaxHeap<E extends Comparable<E>> {
    private Array<E> data;

    public MaxHeap(int capacity) {
        data = new Array<>(capacity);
    }

    public MaxHeap() {
        data = new Array<>();
    }

    //返回堆中的元素个数
    public int size() {
        return data.getSize();
    }

    //堆中是否为空
    public boolean isEmpty() {
        return data.isEmpty();
    }

    //添加元素
    public void add(E e) {
        data.addLast(e); //队尾添加元素
        siftUp(data.getSize() - 1); //因为添加元素后，size++了，需要减回来 ,上浮
    }

    private void siftUp(int index) { //上浮 子节点大于父节点则交换位置
        while (index > 0 && data.get(parent(index)).compareTo(data.get(index)) < 0) {
            data.swap(index, parent(index));
            index = parent(index);
        }
    }

    //看堆中的最大元素
    public E findMax() {
        if (data.getSize() == 0) {
            throw new IllegalArgumentException("Can not find max when heap is empty.");
        }
        return data.get(0);
    }

    //取出堆中最大元素
    public E extractMax() {
        E max = findMax();
        data.swap(0, size() - 1); //将最大元素与堆尾元素交换
        data.removeLast(); //删除堆尾（最大元素）
        siftDown(0); //将第一个元素下沉
        return max;
    }

    private void siftDown(int index) {
        while (leftChild(index) < size()) {
            int max = leftChild(index); //max 暂时是左节点
            if (max + 1 < size() && data.get(max + 1).compareTo(data.get(max)) > 0) {
                max++; //左节点+1 就是 右节点
            }
            if (data.get(index).compareTo(data.get(max)) >= 0) {
                break;
            }
            data.swap(index, max); //交换
            index = max;
        }
    }

    //返回完全二叉树的数组表示中，一个索引所表示的元素的父节点的索引
    private int parent(int index) {
        if (index == 0) {
            throw new IllegalArgumentException("index-0,don't have parent.");
        }
        return (index - 1) / 2;
    }

    //返回完全二叉树的数组表示中，一个索引所表示的元素的左子节点的索引
    private int leftChild(int index) {
        return index * 2 + 1;
    }

    //返回完全二叉树的数组表示中，一个索引所表示的元素的右子节点的索引
    private int rightChild(int index) {
        return index * 2 + 2;
    }
}

Heapfiy 将数组转换为二叉堆

将任意数组转换为二叉堆：

1. 找到最后一个非叶子节点： （size - 1）/ 2 （最后一个元素的父节点）
2. 下沉操作

将数组遍历添加到空数组生成二叉堆：O(nLogn)
Heapify：O( n )

//Array类添加
//构造函数，传入数组构造Array
    public Array(E[] arr) {
        this(arr.length);
        size = arr.length;
        for (int i = 0; i < size; i++) {
            data[i] = arr[i];
        }
    }
    
//Heapfiy---------MaxHeap类添加
//构造函数
   public MaxHeap(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("array don't allow empty");
        }
        data = new Array<>(arr); //对data赋值
        for (int i = parent(arr.length - 1); i >= 0; i--) {
            siftDown(i);
        }
    }

优先队列----二叉堆实现

public class PriorityQueque<E extends Comparable<E>> implements Queue<E> {

    private MaxHeap<E> maxHeap;

    public PriorityQueque() {
        maxHeap = new MaxHeap<>();
    }

    @Override
    public int getSize() {
        return maxHeap.size();
    }

    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }

    @Override
    public void enqueue(E e) {
        maxHeap.add(e);

    }

    @Override
    public E dequeue() {
        return maxHeap.extractMax();
    }

    @Override
    public E getFront() {
        return maxHeap.findMax();
    }

}

LeetCode 347 前 K 个高频元素

LeetCode 347链接

class Solution {

   public List<Integer> topKFrequent(int[] nums, int k) {
        //统计频率
        Map<Integer, Integer> map = new TreeMap<>();
        for (int i : nums) {
            if (map.containsKey(i)) {
                map.put(i, map.get(i) + 1);
            } else {
                map.put(i, 0);
            }
        }

        //使用优先级队列 维护K个元素
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {//自定义比较器
                return map.get(a) - map.get(b);
            }
        });
        //lambda表达式
        //PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(map::get));
        for (int key : map.keySet()) {
            if (pq.size() < k) {//'如果优先级队列小于K个元素，直接添加
                pq.add(key);
            } else if (map.get(key) > map.get(pq.peek())) {//如果当前元素大于最小元素，取出最小元素，存放当前元素
                pq.remove();
                pq.add(key);
            }
        }

        List<Integer> res = new LinkedList<>();
        while (!pq.isEmpty()) {
            res.add(pq.remove());
        }
        return res;
    }
}