C++ 删除倾斜堆的方法？

我正在尝试创建倾斜堆类，但在从堆中删除元素时遇到问题。删除函数位于代码末尾。逻辑似乎正确。找到元素并合并其子元素。有什么建议吗

struct node{
    int key;
    node* left;
    node* right;
};

class skewHeap{
public:
    skewHeap(int k);
    ~skewHeap();
    skewHeap& operator=(const skewHeap&);
    node* merge(node* a,node* b);
    void remove(node* a,int k);
    void add(int k);
    void print(node*) const;
    node* getRoot();
private:
    node* root;
    void del(node* n){
        if(n == NULL) return;
        else{
        del(n->left);
        del(n->right);
        delete n;
        }
    }

    node* copy(node* n){
        if(n == NULL) return NULL;
        node* tmp = new node;
        tmp->key = n ->key;
        tmp->left = copy(n->left);
        tmp->right = copy(n->right);
                 return tmp;
    }


};

skewHeap::skewHeap(int k){
    root = new node;
    root->key = k;
    root->left = NULL;
    root->right = NULL;
}

skewHeap::~skewHeap(){
    del(root);
}

skewHeap& skewHeap::operator=(const skewHeap& n){
    if( this != &n){
        del(root);
        root = n.root;
        copy(root);
    }
    return *this;
}

node* skewHeap::merge(node* a,node* b){
    if(a == NULL) return b;
    if(b == NULL) return a;
    else {
        if(a->key > b->key){
            node* tmp = a;
            a = b;
            b = tmp;
        }
        node* tmp = a->right;
        a->right = a->left;
        a->left = merge(b,tmp);
    }
    return a;
}



void skewHeap::add(int k){
    node* p = new node;
    p->key = k;
    p->left = NULL;
    p->right = NULL;
    root = merge(root,p);
}

void skewHeap::print(node* n) const{
    if(n == NULL) return;
    else{
        print(n->left);
        cout<<n->key<<" ";
        print(n->right);
    }
}

node* skewHeap::getRoot(){
    return root;
}

void skewHeap::remove(node* n,int k){
    if( n == NULL) return;
    if(n->key == k)  {
        n = merge(n->left,n->right);
        return;
        }
    remove(n->left,k);
    remove(n->right,k);
}

struct节点{
int键；
节点*左；
节点*右；
};
类堆{
公众：
斜堆（intk）；
~skewHeap（）；
skewHeap&运算符=（const skewHeap&）；
节点*合并（节点*a、节点*b）；
无效删除（节点*a，int k）；
无效添加（int k）；
无效打印（节点*）常量；
node*getRoot（）；
私人：
节点*根；
void del（节点*n）{
如果（n==NULL）返回；
否则{
del（n->左）；
del（n->右）；
删除n；
}
}
节点*复制（节点*n）{
如果（n==NULL）返回NULL；
node*tmp=新节点；
tmp->key=n->key；
tmp->left=复制（n->left）；
tmp->right=复制（n->right）；
返回tmp；
}
};
skewHeap:：skewHeap（int k）{
根=新节点；
根->键=k；
根->左=空；
root->right=NULL；
}
skewHeap:：~skewHeap（）{
del（根）；
}
skewHeap&skewHeap:：operator=（常量skewHeap&n）{
如果（此！=&n）{
del（根）；
根=n.根；
副本（根）；
}
归还*这个；
}
node*skewHeap:：merge（node*a，node*b）{
如果（a==NULL）返回b；
如果（b==NULL），则返回a；
否则{
如果（a->key>b->key）{
节点*tmp=a；
a=b；
b=tmp；
}
节点*tmp=a->右侧；
a->right=a->left；
a->左=合并（b，tmp）；
}
返回a；
}
void skewHeap:：add（int k）{
node*p=新节点；
p->key=k；
p->left=NULL；
p->right=NULL；
根=合并（根，p）；
}
void skewHeap:：打印（节点*n）常量{
如果（n==NULL）返回；
否则{
打印（n->左）；
coutleft，n->右）；
回来
}
移除（n->左，k）；
移除（n->右侧，k）；
}

这很好（使用此方法跳过根）

---

返回tmp；副本fn中缺少。

node* skewHeap::remove(node* n,int k){
    if( n == NULL) return NULL;

    if(n->left && n->left->key == k)  {
         n->left = merge(n->left->left,n->left->right);
         return n;
    }
    if(n->right && n->right->key == k) {
        n->right = merge(n->right->left,n->right->right);

        return n;
        }
    remove(n->left,k);
    remove(n->right,k);
}