数据结构和算法分析java--优先队列(堆实现)

前言

数据结构 队列的学习中，我们知道队列是先进先出的。任务被提交到队列中，按照先进先出的原则

     对各个任务进行处理。不过在现实的情况下，任务通常有着优先级的概念，例如短任务、管理员的操作

     应该优先执行。这是使用队列就无法描述了，这种特殊的应用我们使用一种称之为优先队列(堆)的方式

     来解决。

优先队列

和队列一样优先队列也支持入队和出队操作，不过区别在于优先队列的出队操作出队的是优先级最高

      的元素，这里以元素的大小来判定任务的优先级，越小，优先级越高。优先队列的模型如下图：

可以使用链表来实现该数据结构，链表以O(1)执行插入操作,,遍历最小元素并删除花费O(N)时间。基于优先队列的插入操作一般情况下多于删除操作这
     一情况， 前者是一种较好的实现。

 另外可以使用二叉查找树来实现，这样一来插入和删除操作都是O（logN），不过二叉树支持多种操作用以实现优先队列未免有点杀猪用牛刀的感觉。  

下面将介绍二叉堆实现优先队列。

二叉堆

              二叉堆就结构性质上来说就是一个完全填满的二叉树，满足结构性和堆序性。结构性不必多说，

      就是完全二叉树应该满足的树结构。堆序性指的是：父节点的键值总是大于或等于（小于或等于）任何

      一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

               最大堆：当父节点的键值总是大于或等于任何一个子节点的键值。

               最小堆：当父节点的键值总是小于或等于任何一个子节点的键值。

 结构性质

上面对二叉堆的结构性质略有提及，这里我们进行下详细说明。看看二叉堆是如何实现的。

 

    仔细观察上述完全二叉树的结构，我们可以发现的是对于任意一个位置i，其结点的左孩子在2i的位置，

右孩子在2i+1的位置上，基于上述的性质我们可以使用数组来实现二叉堆。

由此二叉堆可以使用一个数组和一个代表当前堆的大小的整数组成。考虑到涉及到元素大小的比较，

该数组元素实现了Comparable接口。

二叉堆基本操作

                    基于二叉堆的堆序性，我们来看看二叉堆基本操作是如何实现的吧！

             insert(插入)

                     根据优先队列的模型，二叉堆实现的优先队列应该具备插入操作，不过根据其对序性

                 具体的插入操作是如何进行的呢？看下面的演示：

                     二叉堆插入元素14的情况。

              

                  

            

                     为将一个元素 X 插入到堆中，我们在下一个可用位置创建一个空穴，否则该堆将不是完全数。

               如果 X 可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素

              移入该空穴中，这样，空穴就朝着根的方向上冒一步。继续改过程直到 X 能被放入空穴中为止。

                     这种实现过程称之为上滤：新元素在堆中上滤直到找出正确的插入位置。

deleteMin(删除最小元)

                    基于优先队列的模型,出队的应该是最小元,按照最小堆的堆序性，找出最小元十分容易，麻烦

               的地方在于删除之后破坏了结构型，这是需要进行一些额外的操作。

                    当删除一个最小元时，要在根节点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一

              个元素 X 必须移动到该堆的某个地方。如果 X 可以直接被放到空穴中，那么 deleteMin 完成。

              不过这一般不太可能，因此我们将空穴的两个儿子中比较小者移入空穴，这样就把空穴向下推了

              一层。重复该步骤直到 X 可以被放入空穴中。因此，我们的做法是将 X 置入沿着从根开始包含

             最小儿子的一条路径上的一个正确的位置。

                      演示过程如下:

                 

                      首先我们删除根元素13,建立一个空穴,之后判断元素31是否可以放入这个空穴中,

                   明显不能,会破坏堆序性.

                  

                      之后我们选择较小的左儿子放入空穴,同时空穴下滑一层,之后判断31是否置于空穴中

               

                       同上,26置于空穴中,空穴下滑一层,31可以置于空穴中,过程结束。

                    这一种操作过程称之为下滤:空穴一步步下滑.

   构造二叉堆

                    上述讲了二叉堆的方式实现优先队列。那么一个二叉堆又是如何构造的呢？

               简单的我们可以认为它可以使用N个相继的insert操作来完成。每个insert最坏时间为O(logN)

               则其构建时间为O（N）。

                    更为常用的算法是先保持其结构性，之后再通过检查每个位置，下滤操作使其满足堆序性。

            

                      一开始满足结构性，但是并不满足堆序性，我们在元素70的位置进行下滤操作。

最后，课本给出了最小堆的实现方法，我照着写了最大堆的实现方法。

import java.util.Arrays;

/**
 * Created by mike on 2016/10/7.
 */
public class BinaryMaxHeap <AnyType extends Comparable<? super AnyType>>{

    private static final int DEFAULT_CAPACITY = 10;
    private int currentSize;
    private AnyType[] array;

    public BinaryMaxHeap() {
        this(DEFAULT_CAPACITY);
    }
    public BinaryMaxHeap(int capacity) {
        currentSize = 0;
        enlargeArray(capacity);
    }
    public BinaryMaxHeap(AnyType[] items) {
        currentSize = items.length;
        array =(AnyType[]) new Comparable[(currentSize + 2) * 11 / 10];
        int i = 1;
        for (AnyType item : items)
            array[i++] = item;
        buildMaxHeap();
    }

    private void buildMaxHeap() {
        for (int i = currentSize / 2; i > 0; i--)
            percolateDown(i);
    }

    public void insert(AnyType x) {
        if (isFull()) {
            enlargeArray(2 * array.length + 1);
        }

        int hole = ++currentSize;
        for (;hole > 1 && array[hole / 2].compareTo(x) < 0; hole /= 2) {
            array[hole] = array[hole / 2];
        }
        array[hole] = x;
    }

    public AnyType deleteMax() {
        if (isEmpty())
            return null;

        AnyType maxItems = array[1];
        array[1] = array[currentSize--];
        percolateDown(1);
        return maxItems;
    }

    public void percolateDown(int hole) {
        int child;
        AnyType tmp = array[hole];

        for (; hole * 2 <= currentSize; hole = child) {
            child = hole * 2;
            if (child != currentSize && array[child + 1].compareTo(array[child]) > 0)
                child++;
            if (array[child].compareTo(tmp) > 0)
                array[hole] = array[child];
            else
                break;
        }
        array[hole] = tmp;
    }

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

    public boolean isFull() {
        return currentSize == array.length - 1;
    }

    private void enlargeArray(int newCapacity) {
        if (newCapacity < currentSize)
            return;
        AnyType[] old = array;
        array = (AnyType[]) new Comparable[newCapacity + 1];
        for (int i = 1; i <= currentSize; i++) {
            array[i] = old[i];
        }
    }

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

    public static void main(String[] args) {
        Integer[] array = {2,4,5,6,8,1,0,45,23,43,54};
        BinaryMaxHeap maxHeap = new BinaryMaxHeap(array);
        System.out.println(maxHeap.toString());
        maxHeap.insert(100);
        System.out.println(maxHeap.toString());
        maxHeap.insert(100);
        System.out.println(maxHeap.toString());
        for (int i = 0; i < 13; i++)
            System.out.println(maxHeap.deleteMax());
    }
}