#include <iostream>
#include <assert.h>
using namespace std;

const int MAX_SIZE=100;

/* Note the type ItemType needs to implement comparison operators */
template <class ItemType>
class Heap{
public:
    Heap(){
	heapLength=0;
    }

    //Initialize the heap with the given data, and call build_heap to make it a heap
    Heap(ItemType initData[], int len);

    //return true if heap property is satisfied, false if violated
    bool IsHeap()
    {
		//Todo by you
		return true; //for now 
    }

    /* precondition:
     *   1) heapLength>=i>1
     *   2) node i's left subtree and right subtree meet the heap property, 
     *   node i might violate heap property, 
     * postcondition: the subtree rooted at node i met heap property */
    void heapify(int i);

    /* insert a new item into the heap. 
     * Precondition: length+1<MAX_SIZE; //We have room to grow 
	1. increment heap length by 1
	2. store new item at the end of the heap, say the location is j
	3. walk your way up from node j to root (going one level up to parent in each step,
		compare values stored at a node with its parent and swap
	  the items if necessary.
	  */
    void Insert(ItemType item);

     /*  modify item stored in position i to the newValue, and repair heap property.
      *   Precondition: heap property is statisfied, 
      *   	        1<=i<=length
      *   Postcondition: i-th element is modified, and heap property is satisfied 
      *   Note that you cannot just call build_heap, which is overkill, instead you 
      *   need to repair heap property as efficient as possible).
     When node i's value is changed to a smaller value, then heapify(i) can fix the whole heap.
     When node i's value is changed to a larger value, then the tree rooted at i is still a heap, 
       but the whole tree might not. THink about how to fix! 
      */
    void Modify(int i, ItemType newValue); 

    // return the item stored in the root node of the heap
    ItemType GetRoot();
	

    // remove and return item stored in root from the heap
    ItemType RemoveRoot(){
	ItemType rootElement=data[1];
	//todo by you
	// swap last with root
	// decrease length,
	// heapify from root
	return rootElement;
    }
private:
     //precondition: i is the numbering of node (starting from 1)
     //              i is not 1 (as root node has no parent)
     //postcondition: the numbering of node i's parent is returned
     int parent(int i);     //return i/2 (calculating i/2 using bitewise shift operators)

     //return the numbering of the left child of node i
     // if node i has no left child, return -1 (note use heapLength to see if there is one)
     int leftchild (int i); //return 2*i (calculated using bitwise shift operators)

     //return the numbering of the right child of node i
     // if node i has no right child, return -1 (note use heapLength to see if there is one)
     int rightchild (int i); // return 2*i+1 (left shift, bitwise OR)

    /* Precond: 
      the array has been filled with elements, but heap property is not satisfied
      Postcondition:  rearrange elements so that the whole heap statisfies heap property. 
      *This method should be called in the second constructor*/
    void build_heap(){
	//Todo...
    }

     ItemType data[MAX_SIZE];  //You could store elements from index 1 (i.e., leave
     	//first slot of the array empty), this way, you can use abvoe parent(),leftchild(),
	//rightchild() function to return the location of the nodes
     int heapLength;   // the actual number of elements in the heap
};

 
//Initialize the heap with the given data, and call build_heap to make it a heapt
template <class ItemType>
Heap<ItemType>::Heap(ItemType initData[], int len)
{
   for (int i=0;i<len;i++)
	   data[i] = initData[i];

   heapLength=len;
   build_heap();

   assert (IsHeap());
}