【每日一题】加强堆

题目

设计一个数据结构，1. 在插入数据时可以保证有序，2.在插入相同的数据时，更新该集合中的数据，并且依然保持有序 3. 需要提供删除集合中的指定数据

要求：所有方法的时间复杂度为O(n*logN)

解析

按照题目的要求的函数功能，可以很好实现，但是如果要求时间复杂度为O(N*logN)，那么比较适合的数据结构是堆，但是系统提供的堆(PriorityQueue)不能更新堆中的节点，只能添加，所以需要设计一个加强堆

代码实现

public class HeapGreater<T> {

    private List<T> heap; // 堆数组
    private Map<T,  Integer> indexMap; // 堆的反向索引表
    private int heapSize; // 堆大小
    private Comparator<? super T> comparator; // 比较器

    public HeapGreater(Comparator<T> c) {
        heap = new ArrayList<>();
        indexMap = new HashMap<>();
        heapSize = 0;
        comparator = c;
    }

    public boolean isEmpty() {
        return heapSize == 0;
    }

    public int size() {
        return heapSize;
    }

    public boolean contains(T obj) {
        // 如果用堆需要遍历，但是使用反向索引表，可以直接判断 O(1)
        return indexMap.containsKey(obj);
    }

    public T peek() {
        return heap.get(0);
    }

    public void push(T obj) {
        heap.add(obj);
        indexMap.put(obj, heapSize);
        // 调整顺序之后，将heapSize++, 用于插入下一个位置
        // 从heapSize位置开始向堆中插入数据
        heapInsert(heapSize++);
    }

    public T pop() {
        T t = heap.get(0);
        swap(0, heapSize - 1);
        indexMap.remove(t);
        heap.remove(--heapSize);
        // 从0开始向下调整堆
        heapify(0);
        return t;
    }

    public void remove(T obj) {
        T replace = heap.get(heapSize - 1);
        Integer i = indexMap.get(obj);
        indexMap.remove(obj);
        heap.remove(--heapSize);
        if(obj != replace) {
            heap.set(i, replace);
            indexMap.put(replace, i);
            resign(replace);
        }
    }

    private void resign(T replace) {
        // 向上比较进行调整replace的位置
        heapInsert(indexMap.get(replace));
        // 向下比较进行调整replace的位置
        heapify(indexMap.get(replace));
    }

    public List<T> getAllElements() {
        List<T> list = new ArrayList<>(heap);
        return list;
    }

    private void heapify(int index) {
        int left = index * 2 + 1;
        while (left < heapSize) {
            int best = left + 1 < heapSize && comparator.compare(heap.get(left + 1), heap.get(left)) < 0 ? (left + 1) : left;
            best = comparator.compare(heap.get(best), heap.get(index)) < 0 ? best : index;
            if(best == index) {
                break;
            }
            swap(best, index);
            index = best;
            left = index * 2 + 1;
        }
    }

    private void heapInsert(int index) {
        while (comparator.compare(heap.get(index), heap.get((index - 1) / 2)) < 0) {
            swap(index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    private void swap(int i, int j) {
        T t1 = heap.get(i);
        T t2 = heap.get(j);
        Integer i1 = indexMap.get(t1);
        Integer i2 = indexMap.get(t2);
        heap.set(i2, t1);
        heap.set(i1, t2);
        indexMap.put(t1, i2);
        indexMap.put(t2, i1);
    }


}