第6章 优先队列（堆）

优先队列（堆）

public class BinaryHeap<AnyType extends Comparable<? super AnyType>>
{
    public BinaryHeap(){ this(DEFAULT_CAPACITY); }
    public BinaryHeap(int capacity)
    {
        currentSize = 0;
        array = (AnyType [])new Comparable[capacity + 1];
    }

    public BinaryHeap(AnyType[] items)
    {
        currentSize = items.length;
        array = (AnyType[])new Comparable[(currentSize + 2) * 11 / 10];

        int i = 1;
        for (AnyType item : items)
            array[i++] = item;
        buildHeap();
    }

    public void insert(AnyType x)
    {
        if (currentSize == array.length - 1)
            enlargeArray(array.length * 2 + 1);

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

    private void enlargeArray(int newSize)
    {
        AnyType[] old = array;
        array = (AnyType[])new Comparable[newSize];
        for (int i = 0; i < old.length; i++)
            array[i] = old[i];
    }

    public AnyType findMin()
    {
        if (isEmpty())
            throw new UnderflowException();
        return array[1];
    }

    public AnyType deleteMin()
    {
        if (isEmpty())
            throw new UnderflowException();
        AnyType minItem = findMin();
        array[1] = array[currentSize--];
        percolateDown(1);

        return minItem;
    }

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

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

    public void makeEmpty(){ currentSize = 0; }

    private static final int DEFAULT_CAPACITY = 10;

    private int currentSize;
    private AnyType[] array;

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

左式堆

public class LeftistHeap<AnyType extends Comparable<? super AnyType>>
{
    public LeftistHeap()
    { root = null; }
    
    public void merge(LeftistHeap<AnyType>rhs)
    {
        if (this == null)
            return;
        root = merge(root, rhs.root);
        rhs.root  = null;
    }
    
    private Node<AnyType>merge(Node<AnyType>h1, Node<AnyType>h2)
    {
        if (h1 == null)
            return h2;
        if (h2 == null)
            return h1;
        if (h1.element.compareTo(h2.element) < 0) 
            return merge1(h1,h2);
        else
            return merge1(h2, h1);
    }
    
   private Node<AnyType>merge1(Node<AnyType>h1, Node<AnyType>h2)
   {
       if (h1.left == null) 
           h1.left = h2;
       else 
       {
           h1.right = merge(h1.right, h2);
           if (h1.left.npl < h1.right.npl)
               swapChildren(h1);
           h1.npl = h1.right.npl + 1;
       }
       return h1;
   }
   
   private static <AnyType> void swapChildren(Node<AnyType> t)
   {
       Node<AnyType> tmp = t.left;
       t.left = t.right;
       t.right = tmp;
   }
   
   public void insert(AnyType x){ root = merge(new Node<>(x), root); }
   
   public AnyType findMin()
   {
       if (isEmpty())
           throw new UnderflowException();
       return root.element;
   }
   
   public AnyType deleteMin()
   {
       if (isEmpty())
           throw new UnderflowException();
       
       AnyType minItem = root.element;
       root = merge(root.left, root.right);
       
       return minItem;
   }
   
   public boolean isEmpty()
   { return root == null; }
   public void makeEmpty()
   { root = null; }
    
   private static class Node<AnyType>
   {
       Node(AnyType theElement)
       { this(theElement,null,null); }
       
       Node(AnyType theElement, Node<AnyType>lt, Node<AnyType>rt)
       { element = theElement; left = lt; right = rt; npl = 0; }
       
       AnyType element;
       Node<AnyType> left;
       Node<AnyType> right;
       int npl;
   }
   
   private Node<AnyType> root;
}

二项队列

public class BinomialQueue<AnyType extends Comparable<? super AnyType>>
{
    public BinomialQueue()
    {
        theTrees = new BinNode[DEFAULT_TREES];
        makeEmpty();
    }

    public BinomialQueue(AnyType item)
    {
        currentSize = 1;
        theTrees = new BinNode[1];
        theTrees[0] = new BinNode<>(item, null, null);
    }

    private void expaneTheTrees(int newNumTrees)
    {
        BinNode<AnyType>[] old = theTrees;
        int oldNumTrees = theTrees.length;

        theTrees = new BinNode[newNumTrees];
        for (int i = 0; i < Math.min(oldNumTrees, newNumTrees); i++)
            theTrees[i] = old[i];
        for (int i = oldNumTrees; i < newNumTrees; i++)
            theTrees[i] = null;
    }
    
    public void merge(BinomialQueue<AnyType>rhs)
    {
        if (this == rhs)
            return;
        
        currentSize += rhs.currentSize;
        
        if (currentSize > capacity())
        {
            int newNumTrees = Math.max(theTrees.length, rhs.theTrees.length) + 1;
            expaneTheTrees(newNumTrees);
        }
        
        BinNode<AnyType>carry = null;
        for (int i = 0, j = 1; j <= currentSize; i++,j *= 2)
        {
            BinNode<AnyType>t1 = theTrees[i];
            BinNode<AnyType>t2 = i < rhs.theTrees.length ? rhs.theTrees[i] : null;
            
            int whichCase = t1 == null ? 0 : 1;
            whichCase += t2 == null ? 0 : 2;
            whichCase += carry == null ? 0 : 4;
            
            switch (whichCase)
            {
                case 0:
                case 1:
                    break;
                case 2:
                    theTrees[i] = t2;
                    rhs.theTrees[i] = null;
                    break;
                case 4:
                    theTrees[i] = carry;
                    carry = null;
                    break;
                case 3:
                    carry = combineTrees(t1, t2);
                    theTrees[i] = rhs.theTrees[i] = null;
                    break;
                case 5:
                    carry = combineTrees(t1, carry);
                    theTrees[i] = null;
                    break;
                case 6:
                    carry = combineTrees(t2, carry);
                    theTrees[i] = null;
                    break;
                case 7:
                    theTrees[i] = carry;
                    carry = combineTrees(t1, t2);
                    rhs.theTrees[i] = null;
                    break;
            }
        }
        for (int k = 0; k < rhs.theTrees.length; k++)
            rhs.theTrees[k] = null;
        rhs.currentSize = 0;
    }
    
    private BinNode<AnyType> combineTrees(BinNode<AnyType>t1, BinNode<AnyType>t2)
    {
        if (t1.element.compareTo(t2.element) > 0)
            return combineTrees(t2, t1);
        t2.nextSibling = t1.leftChild;
        t1.leftChild = t2;
        return t1;
    }
    
    public void insert(AnyType x){ merge(new BinomialQueue<>(x)); }
    
    public AnyType findMin()
    {
        if (isEmpty())
            throw new UnderflowException();
        
        return theTrees[findMinIndex()].element;
    }
    
    private int findMinIndex()
    {
        int i;
        int minIndex;
        
        for (i = 0; theTrees[i] == null; i++)
            ;
        for (minIndex = i; i < theTrees.length; i++)
            if (theTrees[i] != null && theTrees[i].element.compareTo(theTrees[minIndex].element) < 0 )
                minIndex = i;
            
        return minIndex;
    }
    
    private AnyType deleteMin()
    {
        if (isEmpty())
            throw new UnderflowException();
        
        int minIndex = findMinIndex();
        AnyType minItem = theTrees[minIndex].element;
        
        BinNode<AnyType>deletedTree = theTrees[minIndex].leftChild;
        
        BinomialQueue<AnyType>deletedQueue = new BinomialQueue<>();
        deletedQueue.expaneTheTrees(minIndex);
        
        deletedQueue.currentSize = (1 << minIndex ) - 1;
        
        for (int j = minIndex - 1; j >= 0; j--)
        {
            deletedQueue.theTrees[j] = deletedTree;
            deletedTree = deletedTree.nextSibling;
            deletedQueue.theTrees[j].nextSibling = null;
        }
        
        theTrees[minIndex] = null;
        currentSize -= deletedQueue.currentSize - 1;
        
        merge(deletedQueue);
        
        return minItem;
    }

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

    public void makeEmpty()
    {
        currentSize = 0;
        for (int i = 0; i < theTrees.length; i++)
            theTrees[i] = null;
    }

    private static class BinNode<AnyType>
    {
        BinNode(AnyType theElement)
        { this(theElement, null, null); }
        BinNode(AnyType theElement, BinNode<AnyType>lt, BinNode<AnyType>nt)
        { element = theElement; leftChild = lt; nextSibling = nt; }

        AnyType element;
        BinNode<AnyType> leftChild;
        BinNode<AnyType> nextSibling;
    }

    private static final int DEFAULT_TREES = 1;

    private int currentSize;
    private BinNode<AnyType>[] theTrees;

    private int capacity(){ return ( 1 << theTrees.length ) - 1; }
}