左式堆 优先级队列类模板 归并排序

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <string>
#include <cstdlib>
#include<algorithm>
using namespace std;


template <class elem>
class priorityqueue
{
private:
    struct node
    {
        node* left;
        node* right;
        elem data;
        int npl;
        node(node* left_i, node* right_i, elem data_i, int npl_i):left(left_i),right(right_i),data(data_i),npl(npl_i){}
    };
    node* root;
    int currentsize;
public:
    node* getroot()
    {
        return root;
    }
    int size()
    {
        return currentsize;
    }
    priorityqueue()
    {
        currentsize = 0;
        root = NULL;
    }
    priorityqueue(node* p, int size)
    {
        currentsize = size;
        root = p;
    }
    priorityqueue(elem data)
    {
        currentsize = 1;
        root = new node(NULL, NULL, data, 0);
    }
    ~priorityqueue()
    {
        while (currentsize)
            dequeue();
    }
    void swap(node* p)
    {
        node* tmp = p->left;
        p->left = p->right;
        p->right = tmp;
    }

    void enqueue(elem data)
    {
        node* p = new node(NULL, NULL, data, 0);
        root = merge(root, p);
        currentsize++;
    }

    elem dequeue()
    {
        elem tmp = root->data;
        node* del = root;
        root = merge(root->left, root->right);
        delete del;
        currentsize--;
        return tmp;
    }

    static priorityqueue treemerge(priorityqueue& n1, priorityqueue& n2)
    {
        return priorityqueue(n1.merge(n1.getroot(), n2.getroot()), n1.size() + n2.size());
    }

    node* merge(node* n1, node* n2)//whether continue or direction? (minimum leftist heaps)
    {
        if (n1 == NULL)
            return n2;
        if (n2 == NULL)
            return n1;
        if (n1->data < n2->data)
        {
            mergeoperate(n1, n2);
            return n1;//
        }
        else
        {
            mergeoperate(n2, n1);
                return n2;//
        }
    }
    node* mergeoperate(node* n1, node* n2)
    {
        if (n1->left == NULL)
        {
            n1->left = n2;
            return n1;
        }
        else
        {
            n1->right = merge(n1->right, n2);
            if (n1->left->npl < n1->right->npl)
            {
                swap(n1);
            }
            n1->npl = n1->right->npl + 1;
        }
        return n1;
    }


};