【資料結構】堆的建立以及其他操作！！！

堆的概念：堆是一組將 元素按照完全二叉樹的形式儲存在一個人以為陣列裡面並且在這個完全二叉樹裡面滿足父節點和子節點的關係為Ki <= K2*i+1 且 Ki<= K2*i+2(Ki >= K2*i+1 且 Ki >= K2*i+2) i = 0，1，2…， 的一種資料結構。
分類：

• 小堆

• 大堆
  

  大堆的小堆的建立
  建立堆：

在建立堆的時候採用的是向下調整的方式，即從最後一個非葉節點開始向下調整，當調整到根節點的時候為止。
程式碼：

  void _AdjustDown(int parent)
        {
            int child = parent*2 + 1;
            Compare Cmp;
            int size = hp.size();
            while(child < size)
            {
                if(child +1< size && Cmp(hp[child] , hp[child+1]))
                    child = child +1;
                if(Cmp(hp[parent] , hp[child]))
                    swap(hp[child] , hp[parent]);
                else
                    break;
                parent = child;
                child = parent*2+1;
            }
        }

建立大堆的程式碼：

Heap(T* arr,size_t size)
        {
            if(NULL == arr)
                return ;
            for(int i=0;i<size;i++)
                hp.push_back(arr[i]);
            for(int j = (hp.size()-2)>>1;j >= 0;j--)
                _AdjustDown(j);
        }

在上面的程式碼裡面含有一個選擇器，使用者可以利用選擇器來自由選擇需要建立的堆是大堆還是小堆，選擇器的程式碼：

template<class T>
class less
{
    public:
    bool operator()(const T left,const T right)
    {
        return left > right;
    }
};

template<class T>
class Grate
{
    public:
    bool operator()(const T left,const T right)
    {
        return left < right;
    }
};

然後在堆的建立類裡面就可以使用這個選擇類來使建立的堆是按照自己的方式建立的。
在堆類裡面就可以這樣呼叫：

template< typename T , class Compare = less<T> >

堆在建立的時候是按照二叉樹的形式來建立的但是在實際的記憶體裡面儲存的時候確實按照以為陣列的形式在儲存這些元素的，所以在這個對遍歷的時候就可以按照對陣列的遍歷方式來進行一系列的操作。
完整的堆程式碼：

#ifndef __HEAP_H__
#define __HEAP_H__

#include<vector>
#include<iostream>
using namespace std;

template<class T>
class less
{
    public:
    bool operator()(const T left,const T right)
    {
        return left > right;
    }
};

template<class T>
class Grate
{
    public:
    bool operator()(const T left,const T right)
    {
        return left < right;
    }
};


template< typename T , class Compare = less<T> >
class Heap
{
    public:
        Heap()
        {}
        Heap(T* arr,size_t size)
        {
            if(NULL == arr)
                return ;
            for(int i=0;i<size;i++)
                hp.push_back(arr[i]);
            for(int j = (hp.size()-2)>>1;j >= 0;j--)
                _AdjustDown(j);
        }
        void Show()
        {
            int size = hp.size();
            for(int i =0;i<size;i++)
                cout<<hp[i]<<" ";
            cout<<endl;
        }
        void Insert(T d)
        {
            _Insert(d);
        }
        void Pop()
        {
            _Pop();
        }
        T& Top()
        {
            return hp.front();
        }
        T& Back()
        {
            return hp.back();
        }
        void _Pop()
        {
            if(hp.empty())
                return ;
            int size = hp.size();
            swap(hp[0],hp[size -1]);    //swap first and last data,next pop last data
            hp.pop_back();          //pop last data
            if(size > 1)
                _AdjustDown(0);       //adjust data 
        }

        bool Empty()
        {
            return hp.empty();
        }


        void _Insert(T d)
        {
            hp.push_back(d);
            int size = hp.size();
            for(int i=size-1;i>0;i--)
                 _AdjustUp(i);
        }
        void _AdjustDown(int parent)
        {
            int child = parent*2 + 1;
            Compare Cmp;
            int size = hp.size();
            while(child < size)
            {
                if(child +1< size && Cmp(hp[child] , hp[child+1]))
                    child = child +1;
                if(Cmp(hp[parent] , hp[child]))
                    swap(hp[child] , hp[parent]);
                else
                    break;
                parent = child;
                child = parent*2+1;
            }
        }

        void _AdjustUp(int child)
        {
            int parent = (child-1)>>1;
            int size = hp.size();
            T p = hp[child];
            while(child >= 0)
            {
                if(parent >= 0 && p > hp[parent])
                {
                    hp[child] = hp[parent];
                    child = parent;
                    parent = (parent-1)>>1;
                }
                else
                    break;
            }
            hp[child] = p;
        }

        vector<T> hp;
};

#endif //__HEAP_H__