Question

#ifndef HEAP_H_
#define HEAP_H_



namespace cse {

    template<typename dtype>
    class heap {

    public:
        /** TO DO:: default constructor 
            perform new to reserve memory of size INITIAL_CAPACITY.
            set num_items = 0;
         */
        heap() {
            // write your code here
          
        };

        /** Create a heap from a given array */
        heap(dtype *other, size_t len) {
            // write your code here
        };

        /** copy constructor
            copy another heap to this heap.
         */
        heap(const heap<dtype> &other) {
            //write your code here
        };


        /** Accessor functions */

        /** returns the root of the heap */
        dtype &root();

        /** returns the left child of the given node. */
        size_t left(size_t index);


        /** returns the right child of the given node. */
        size_t right(size_t index);

        /** returns the parent of the given node. */
        size_t parent(size_t index);

        /** returns num_items of the array */
        size_t size();

        /** Core heap operations */

        /** perform heapify operation over the array. */
        void heapify(size_t index);

        /** create a heap from the given input. */
        void build_heap();

        /** heap sort
          create a copy darray to sorted_array.
          then perform heapsort over sorted_array.
          */
        void heapsort();


        /* insert items into heap */
        void insert(const dtype &key);

        /* remove items from the heap*/
        void remove();

        /** print heap **/
        void print(std::string name);


    private:
        static const size_t INITIAL_CAPACITY;
        size_t num_items;
        dtype *darray;
        dtype *sorted_array;


    }; //end of class heap


    template<typename dtype>
    const size_t heap<dtype>::INITIAL_CAPACITY = 100;
}
    /** TO DO : implement all the member functions here. 


} //end of namespace
     **/


#endif

Answer 1

#ifn def HEAP H #define HEAP H #include <vector> #include <stdexcept> using namespace std; templatetypename T> class Heap public: Heap ) Heap (T elements,int arraySize); T remove ) throw (runtime error) void add (T element) int getSize ); private: vector<T> v template <typename T> Heap<T>:Heap () template <typename T> Heap<T>:Heap (T elements[l, int arraySize) for (int i- 0; i < arraySize; i++) add (elements[i]); template <typename T> T HeapKT: :remove() throw (runtime error)

if (v.size 0) throw runtime_error ("Heap is empty") T removedElement = v[0]; v[0] = v[v . size ( ) -1]; v.pop backO int current!ndex = 0; while (currentIndex < v.size)) int leftChildIndex2 * currentIndex 1: int rightChildIndex = 2 * current!ndex + 2; if (leftChildIndex >= v. size()) break; int maxindex = leftChildIndex; if (rightchildIndex < v.size )) if (v[maxIndex] < v[rightChildIndex]) maxindex = rightChildIndex ; if (v[currentIndex]< v[maxIndex]) T temp = v[maxindex); vlmaxindex] = v[ current Index); v[current Index]tempi currentIndex = maxindex ; else break; return removedElement;

template <typename T> void Heap<T>: :add(T element) v.push _back (element) int currentindex=v.size() - 1; while (currentIndex > 0) int parentindex = (currentIndex- 1) / 2; if (v[currentIndex] > v[parentIndex] > 0) T temp = v[currentIndex) ; v[currentIndex] V[parent Index] v [parentIndex] temp; else break: // the tree is a heap now current!ndex parentIndex = template <typename T> int Heap<T>: :getsize () return v.size (); #endi f