类包装的优先队列 小顶堆实现

最近实习时比较了一下链表实现的优先队列和用堆实现的优先队列时间的差距。。发现数据大了后差的真是超多。。
数据量到了100000后前者需要25秒左右的时间，而后者只需0.03秒左右。（当然与机房实习时的机子烂也有关系）

#include <iostream>
#include <algorithm>
using namespace std;
template<class T>
class Vector
{
private:
    int Size;
    int num;

public:
     T *arr;
    Vector<T>()
    {
        Size=4;
        num=0;
        arr=new T[4];
    }
    bool isempty()
    {
        if(num==0)
            return true;
        else
            return false;
    }
    void Resize(int n)
    {
        arr=new T[n];
    }
    void Clear()
    {
        delete arr;
        arr=new T[4];
    }
    int getSize()
    {
        return num;
    }
    void Push(T record)
    {
        if(num==Size)
        {
            Size=Size*2;
            T *temparr=new T[Size];
            for(int i=0; i<num; i++)
            {
                temparr[i]=arr[i];
            }
            arr=temparr;
            arr[num++]=record;
        }
        else
        {
            arr[num++]=record;
        }
    }
    void deletetail()
    {
        num--;
    }
    void Pop()
    {
        if(!isempty())
        {
            arr[num-1]=0;
            num--;
        }
        else
        {
            cout<<"vector空删除不了"<<endl;
        }
    }
    T& Record(int index)
    {
        return arr[index];
    }
    Vector<T>& operator =(const Vector<T> &a)
    {
        this.num=a.num;
        this.Size=a.Size;
        this.arr=new int[this.Size];
        for(int i=0; i<this.num; i++)
            this.arr[i]=a.arr[i];
    }
};
template<class T>
class Priority_queue
{
private:
    Vector<T> heap;
    int num;
public:
    Priority_queue<T>()
    {
        num=0;
    }
    bool isempty()
    {
        if(num==0)
            return true;
        else
            return false;
    }
    void enqueue(T record)
    {
        heap.Push(record);
        num++;
        insertadjast(num-1);
    }
    void dequeue()
    {
       heap.arr[0]=heap.arr[num-1];
       heap.deletetail();
       num--;
       heapadjast(0,num-1);
    }
    T top()
    {
        return heap.arr[0];
    }
    void heapadjast(int start,int length)
{
    int cur=start;
    int child=start*2+1;
    T temp=heap.arr[cur];
    while(child<=length)
    {
        if(child+1<=length&&heap.arr[child+1]<heap.arr[child])child++;
        if(temp<heap.arr[child])
            break;
        else
        {
            heap.arr[cur]=heap.arr[child];
            cur=child;
            child=2*child+1;
        }
    }
    heap.arr[cur]=temp;
}
void insertadjast(int start)
{
    if(start==0)
    {

    }
    else
    {
    int cur=start;
    int par=(start-1)/2;
    T temp=heap.arr[cur];
    while(par>=0)
    {
        if(temp>heap.arr[par])
            break;
        else
        {
            heap.arr[cur]=heap.arr[par];
            cur=par;
            par=par-1;
            if(par<0)
                break;
            par=par/2;
        }
    }
    heap.arr[cur]=temp;
    }
}

};

int main()
{
    Priority_queue<int> q;
    int num;
    cin>>num;
    for(int i=0;i<num;i++)
    {
        int x;
        cin>>x;
        q.enqueue(x);
        cout<<q.top()<<endl;;
    }
    while(!q.isempty())
    {
        cout<<q.top()<<endl;
        q.dequeue();
    }
}