【資料結構】堆排序和模擬實現優先順序佇列！！

在很多的時候佇列的輸出不一定是先進先出的原則，同時也存在優先順序佇列。

> 在模擬實現的時候就可以根據這個優先順序的不同來建立這個佇列，即根據這個優先順序陣列來建立一個堆，那麼在輸出這個堆的時候就可以實現根據優先順序的不同來建立不同優先順序的佇列

程式碼：

template<class T>
class Priority
{
public:
    Priority()
    {}
    Priority(T* arr,size_t size)
    {
        if(NULL == arr)
            return ;
        for(size_t i=0;i<size;i++)
            s.push_back(arr[i]);
        for(int j=(s.size()-2)>>1;j>=0;j--)
            _AdjustDown(j);
    }
    void Pop()
    {
        _Pop();
    }
    void Push(T d)
    {
        s.push_back(d);
        _AdjustUp(s.size()-1);
    }
    T& Top()
    {
        return s.front();
    }
    size_t Size()
    {
        return s.size();
    }
    bool Empty()
    {
        return s.empty();
    }
private:
    void _Pop()
    {
        if(s.empty())
            return ;
        s.pop_back();
        for(int i=s.size();i>=0 ;i++)
            _AdjustDown(i);
    }
    void _AdjustDown(int parent)
    {
        int child = parent*2 + 1;
        int size = s.size();
        while (child < size)
        {
            int tmp = child;
            if(child+1 <size && s[child] < s[child + 1])
                tmp += 1;
            if(s[tmp] > s[parent])
            {
                swap(s[tmp] , s[parent]);
                parent = tmp;
                child = parent * 2 + 1;
            }
            else
                break;
        }
    }
    void _AdjustUp(int child)
    {
        int parent = (child-1)>>1;
        int size = s.size();
        while(child > 0)
        {
            if(child+1 < size && s[child] < s[child + 1])
                child += 1;
            if(s[child] > s[parent])
                swap(s[child] , s[parent]);
            else
                break;
            child = parent;
            parent = (parent-1)>>1;
        }
    }
    vector<T> s;
};

堆排序：

> 在建立堆的時候可以建立大小堆，那麼在這個堆的堆頂元素就是這個堆裡面的最大（最小）元素,那麼可以利用這個性質進行對陣列的排序。


 - 先將陣列裡面的元素建立一個堆
 - 再將堆頂的元素一個一個放入需要排序的陣列裡面
 - 再將堆頂元素pop
 - 當堆為empty時候這個陣列就已經排序好了

程式碼：

#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();
            while(child > 0)
            {
                if(hp[child] > hp[parent])
                {
                    swap(hp[child], hp[parent]);
                    child = parent;
                    parent = (parent-1)>>1;
                }
                else
                    break;
            }
        }  
        vector<T> hp;
};

template<class T>
void HeapSort(T* arr,size_t size)
{
    if(NULL == arr)
        return ;
    Heap<T> h(arr,size);
    for(int i=0;i < size; i++)
    {
        arr[i] = h.Top();
        h.Pop();
    }
}