【数据结构】堆排序和模拟实现优先级队列！！

在很多的时候队列的输出不一定是先进先出的原则，同时也存在优先级队列。

> 在模拟实现的时候就可以根据这个优先级的不同来创建这个队列，即根据这个优先级数组来创建一个堆，那么在输出这个堆的时候就可以实现根据优先级的不同来创建不同优先级的队列

代码：

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