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;
}