Data Structures (Weiss) Chapter 6: Binary Heap, Priority Queue

//

//  main.cpp

//  Data Structure TRY1

//

//  Created by zr9558 on 6/7/13.

//  Copyright (c) 2013 zr9558. All rights reserved.

//

// Data Structure C++, Weiss, P.216 Priority Queues (Heaps)

// Here, we do not use array[0], the priority queue is from array[1].

#include<iostream>

using namespace std;

#include<vector>

#include<list>

#include<algorithm>

template<typename Comparable>

class BinaryHeap

{

public:

    BinaryHeap( int capacity=100):array(capacity){ currentSize=0;}

    BinaryHeap( const vector<Comparable> &items)

    :array(items.size()+10), currentSize(items.size())

    {

        for( int i=0; i<items.size(); ++i)

            array[i+1]=items[i];

        

        buildHeap();

    }

    

    bool isEmpty() const

    {

        return currentSize==0;

    }

    

    const Comparable &findMin() const

    {

        return array[1];

    }

    

    void insert( const Comparable &x);

    

    void deleteMin(); // delete minimum from the binaryheap;

    void deleteMin( Comparable & minItem); // delete minimum from the binaryheap, and save the minimum in minItem;

    

    void makeEmpty()

    {

        array.clear();

    }

    

    

private:

    int currentSize;          // Number of elements in heap

    vector<Comparable> array; // The heap array

    

    void buildHeap()

    {

        for( int i=currentSize/2; i>0; --i)

            percolateDown(i);

    }

    

    void percolateDown( int hole)

    {

        int child;

        Comparable tmp=array[hole];

        

        for(; hole*2<=currentSize; hole=child)

        {

            child=hole*2;

            if( child!=currentSize && array[child+1]<array[child])

                child++;

            if( array[child]<tmp)

                array[hole]=array[child];

            else break;

        }

        array[hole]=tmp;

    }

};

template<typename Comparable>

void BinaryHeap<Comparable>::insert( const Comparable &x)

{

    if( currentSize==array.size()-1)

        array.resize(2*array.size());

    

    //Percolate up

    int hole=++currentSize;

    for(; hole>1 && x<array[hole/2]; hole/=2)

        array[hole]=array[hole/2];

    

    array[hole]=x;

}

template<typename Comparable>

void BinaryHeap<Comparable>::deleteMin()

{

    array[1]=array[currentSize--];

    percolateDown(1);

}

template<typename Comparable>

void BinaryHeap<Comparable>::deleteMin( Comparable &minItem)

{

    minItem=array[1];

    

    array[1]=array[currentSize--];

    percolateDown(1);

}

int main()

{

    BinaryHeap<int> H;

    

    for( int i=5; i<40; ++i)

        H.insert(i%23);

    

    while( !H.isEmpty())

    {

        cout<<H.findMin()<<" ";

        H.deleteMin();

    }

    

    cout<<endl;

    

    

    

    return 0;

}