二叉堆树实现

1.1 基本概念

二叉堆是一颗完全二叉树(区别于满二叉树)，堆中某个结点的值总是不大于其父节点的值，通常这种堆称为最大堆(相应的可以定义最小堆)，下层的某一元素不一定小于上层的某一元素。

1、大顶堆(最大堆)

最大堆的任何一个父节点的值，都大于或等于它左、右孩子节点的值。

2、小顶堆(最小堆)

最小堆的任何一个父节点的值，都小于或等于它左、右孩子节点的值。

二叉堆的根节点叫作堆顶

最大堆和最小堆的特点决定了：最大堆的堆顶是整个堆中的最大元素，最小堆的堆顶是整个堆中的最小元素。

1.2存储原理

完全二叉树比较适合用数组来存储。用数组来存储完全二叉树是非常节省存储空间的。因为我们不需要存储左右子节点的指针，单纯地通过数组的下标，就可以找到一个节点的左右孩子节点和父节点。

从图中我们可以看到，数组中下标为 i 的节点的左子节点，就是下标为left child(i) = i∗2 +1的节点，右子节点就是下标为right child(i) = i∗2 +2的节点，父节点就是下标为parent(i) = (i-1) /2取整的节点。

1.3 思路分析

1、添加元素

堆中的元素是使用数组的样式排列的，添加元素相当于是层序遍历的最右边，也就是最下面一层的最右添加元素，从数组的表示角度就是在索引为【10】的位置添加了元素【52】这个值。

这显然不满足堆的性质，所有要拿添加的元素跟父节点进行比较，发现元素【52】比【16】大，所以需要交换两个元素的位置。

以【52】为根的二叉树满足了堆的性质，但是这样明显不够的，【52】这个节点比它的父节点【41】还要大，所以两者之间还要进行元素交换。

此时【52】是小于【62】这个元素节点的，满足堆的性质。所以在这个位置上没有破坏堆的性质。

2、删除元素

从堆中取出元素，只拿出最大的元素，堆顶元素，取出堆顶元素。

将堆中的最后元素【16】顶到堆顶去，这样操作完以后，索引为0的元素为【16】，最后一个元素也是16，然后将最后一个元素删除。从元素的个数上成功的减少了一个元素，并且就是堆顶的那个元素。

不过现在堆顶的元素打破了堆的性质，此时应该执行下沉操作，让下沉元素跟它的左右孩子进行比较。选择孩子中最大的那个元素，如果小于最大的那个元素，那么就进行交换。

然后继续比较，继续交换。

此时下沉节点比15要大，满足堆的基本性质，此时下沉操作已经结束了。

1.4 代码实现

1、顺序表：ArrayList

package cn.heap.demo01;

import java.util.Iterator;

public class ArrayList<E> implements Iterable<E>{
    // 顺序表的元素
    private E[] data;
    // 顺序表元素的数量
    private int size;

    // 定义常量
    private static final int ELEMENT_NOT_FOUND = -1;
    private static final int DEFAULT_CAPACITY = 6;

    // 元素的数量
    public int size() {
        return size;
    }

    //清除所有元素
    public void clear() {
        for (int i = 0; i < size; i++) {
            data[i] = null;
        }
        size = 0;
    }


    // 构造函数，传入数组的容量capacity构造SqList
    public ArrayList(int capacity){
        data = (E[]) new Object[capacity];
        capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
    }

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

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

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

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

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

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

    // 在index索引的位置插入一个新元素e
    public void add(int index, E e){
        // 扩容操作
        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 ++;
    }

    // 获取index索引位置的元素
    public E get(int index){
        rangeCheck(index);
        return data[index];
    }

    // 查看元素的索引
    public int indexOf(E e){
        if (e == null) {
            for (int i = 0; i < size; i++) {
                if (data[i] == null) return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (e.equals(data[i])) return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e){
        rangeCheck(index);
        data[index] = e;
    }

    // 查找数组中是否有元素e
    public boolean contains(E e){
       return indexOf(e) != ELEMENT_NOT_FOUND;
    }

    // 查找数组中元素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){
        rangeCheck(index);
        E ret = data[index];
        for(int i = index + 1 ; i < size ; i ++){
            data[i - 1] = data[i];
        }
        // 置空
        data[--size] = null;

        // 缩容操作
        if(size == data.length / 4){
            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);
        }
    }

    // 数组索引越界处理
    private void outOfBounds(int index){
        throw new IndexOutOfBoundsException("index:" + index + ", Size:" + size);
    }

    // 索引值检查范围方法
    private void rangeCheck(int index){
        if(index < 0 || index >=size){
            // 调用越界处理方法
            outOfBounds(index);
        }
    }

    // 添加方法索引检查范围
    private void rangeCheckAdd(int index){
        if(index < 0 || index >size){
            // 调用越界处理方法
            outOfBounds(index);
        }
    }

    // 扩容capacity方法
    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++){
            newData[i] = data[i];
        }
        data = newData;
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("顺序表(ArrayList)长度:%d, 容器:%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();
    }

    // 交换方法
    public void swap(int i, int j){
        E temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    // 遍历方法
    @Override
    public Iterator<E> iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator{
        // 定义一个指针变量
        private int cur;
        public SIterator(){
            this.cur=0;
        }
        @Override
        public boolean hasNext() {
            return cur< size;
        }
        @Override
        public E next() {
            return data[cur++];
        }
    }
}

2、最大堆：MaxHeap

package cn.heap.demo01;

import java.util.Iterator;

/***
 * 最大堆实现
 * @param <E>
 */
public class MaxHeap<E extends Comparable<E>> implements Iterable<E>{
    // 用ArrayList当做最大堆的存储容器
    private ArrayList<E> data;
    // 堆空间
    public MaxHeap(){
        data = new ArrayList<>();
    }

    // 获取父节点的索引
    private int parent(int k){
        if(k <= 0){
            throw new IllegalArgumentException("没有父节点!");
        }
        return (k -1 ) / 2;
    }

    // 获取左孩子结点的索引
    private int leftChild(int k){
        return 2 * k + 1;
    }

    // 获取右孩子结点的索引
    private int rightChild(int k){
        return 2 * k + 2;
    }

    // 返回最大堆有效元素的个数
    public int size(){
        return data.size();
    }

    // 判断二叉堆是否为空
    public boolean isEmpty(){
        return data.isEmpty();
    }

    // 清空二叉堆
    public void clear(){
        data.clear();
    }

    // 向最大堆中添加一个元素e
    public void add(E e){
        data.addLast(e);
        // 上浮元素对应的索引
        siftUp(data.size() -1);
    }

    // 将角标K所对应的元素进行上浮
    private void siftUp(int k){
        // 父亲节点比自己还要小的话，交换元素
        while (k > 0 && data.get(k).compareTo(data.get(parent(k))) < 0){
            data.swap(k, parent(k));
            k = parent(k);
        }
    }

    // 找到最大堆
    public E findMax(){
        if (data.isEmpty()){
            throw new IllegalArgumentException("最大堆为空!!!!");
        }
        return data.get(0);
    }

    // 最小堆
    public E findMin(){
        if(data.isEmpty()){
            throw new IllegalArgumentException("最大堆为空!!!");
        }
        E min = data.get(0);
        for (int i=1; i< data.size(); i++){
            if(data.get(i).compareTo(min) < 0){
                min = data.get(i);
            }
        }
        // 返回最小堆
        return min;
    }

    // 删除最大值
    public E extractMax(){
        // 拿到最大值
        E max = findMax();
        // 将索引为0和最后一个元素交换位置
        data.swap(0, data.size() - 1);
        // 将最后一个元素删除
        data.remove(data.size() - 1);

        // 调用函数
        siftDown(0);
        return max;
    }

    // 下浮
    private void siftDown(int k) {
        while (leftChild(k) < data.size()){
            // 拿到左右孩子的最大值
            int j = leftChild(k);
            if(j + 1 < data.size() && data.get(j+1).compareTo(data.get(j)) > 0){
                // data[j] 是leftChild和rightChild中的最大值
                j = rightChild(k);
            }
            if(data.get(k).compareTo(data.get(j)) < 0){
                data.swap(k,j);
                k = j;
            }else {
                break;
            }
        }
    }

    // 取出最大元素后，放入一个新元素
    public E replace(E e){
        E ret = findMax();
        data.set(0, e);
        siftDown(0);
        return ret;
    }

    @Override
    public Iterator<E> iterator() {
        return data.iterator();
    }

    @Override
    public String toString(){
        return data.toString();
    }
}

3、测试类：TestMaxHeap

package cn.heap.demo01;

import java.util.Random;

public class TestMaxHeap {
    public static void main(String[] args) {
        MaxHeap<Integer> heap = new MaxHeap<>();
        Random random = new Random();
        // 遍历添加
        for (int i=0; i<10; i++){
            heap.add(random.nextInt(20));
        }

        System.out.println(heap);

        for (int i=0; i<4; i++){
            System.out.println(heap.extractMax());
        }
    }
}

4、执行结果

1.5 优先队列

1、基本介绍

普通队列：先进先出，后进后出。

优先队列：出队顺序和入队顺序无关，和优先级相关，本质还是队列。

应用：任务管理器中:动态选择优先级最高的任务执行，游戏中:塔防优先攻击(距离,威胁，先后)。

2、案例实现

接口：Queue

package cn.heap.demo02;

public interface Queue<E> extends Iterable<E>{
    int size();
    boolean isEmpty();
    // 入队操作
    void enqueue(E element);
    // 出队操作
    E dequeue();
    // 查看当前队首的元素
    E getFront();
    // 清空队列
    void clear();
}

优先队列：PriorityQueue

package cn.heap.demo02;

import java.util.Iterator;

public class PriorityQueue<E extends Comparable<E>> implements Queue<E>{
    // 堆对象
    private MaxHeap<E> heap;
    // 构造器
    public PriorityQueue(){
        heap = new MaxHeap<>();
    }

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

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

    @Override
    public void enqueue(E element) {
        // 入队操作
        heap.add(element);
    }

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

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

    @Override
    public void clear() {
        heap.clear();
    }

    @Override
    public Iterator<E> iterator() {
        return heap.iterator();
    }

    @Override
    public String toString() {
        return heap.toString();
    }
}

测试类：TestPriorityQueue

package cn.heap.demo02;

import java.util.Random;

public class TestPriorityQueue {
    public static void main(String[] args) {
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        Random random = new Random();
        // 遍历添加
        for (int i=0; i<10; i++){
            queue.enqueue(random.nextInt(20));
        }

        System.out.println(queue);

        for (int i=0; i<4; i++){
            System.out.println(queue.dequeue());
        }
    }
}

执行结果