Splay tree [to do]

#include <bits/stdc++.h>
#define NIL nullptr
using namespace std;

struct Node
{
    int key;
    Node *left, *right, *parent;
    Node (int x)
    {
        this->left=NIL;
        this->right=NIL;
        this->parent=NIL;
        this->key=x;
    }
};

class SplayTree
{
private:
    Node *root;
    void zig (Node *);
    void zig_zig (Node *);
    void zig_zag (Node *);
public:
    SplayTree ();
    SplayTree (int);
    void splay (Node *);
    void insert (int);
    void remove (int);
    Node* min (Node *);
    Node* max (Node *);
    Node* find (int);
};

SplayTree::SplayTree ()
{
    this->root=NIL;
}

SplayTree::SplayTree (int x)
{
    this->root=new Node(x);
}

void SplayTree::zig (Node *x)
{
    Node *p=x->parent;

    if (p->left==x) //right rotation
    {
        Node *B=x->right;
        p->left=B;
        if (B) B->parent=p;
        x->right=p;
        p->parent=x;
    }
    else if (p->right==x) //left rotation
    {
        Node *B=x->left;
        p->right=B;
        if (B) B->parent=p;
        x->left=p;
        p->parent=x;
    }

    x->parent=NIL;
}

void SplayTree::zig_zig (Node *x)
{
    Node *p=x->parent;
    Node *g=p->parent;
    Node *gg=g->parent;

    if (g->left==p && p->left==x) //double right rotation
    {
        Node *B=x->right;

        p->left=B;
        if (B) B->parent=p;
        p->parent=g;

        g->left=p;
        g->parent=x;

        x->right=g;
        x->parent=gg;

        if (gg && gg->left==g) gg->left=x;
        else if (gg && gg->right==g) gg->right=x;
    }
    else if (g->right==p && p->right==x) //double left rotation
    {
        Node *B=x->left;

        p->right=B;
        if (B) B->parent=p;
        p->parent=g;

        g->right=p;
        g->parent=x;

        x->left=g;
        x->parent=gg;

        if (gg && gg->left==g) gg->left=x;
        else if (gg && gg->right==g) gg->right=x;
    }
}

void SplayTree::zig_zag (Node *x)
{
    Node *p=x->parent;
    Node *g=p->parent;
    Node *gg=g->parent;

    if (g->left==p && p->right==x) //left rotation; right rotation
    {
        Node *B=x->left;
        Node *C=x->right;

        p->right=B;
        if (B) B->parent=p;
        p->parent=x;

        g->left=C;
        if (C) C->parent=g;
        g->parent=x;

        x->left=p;
        x->right=g;
        x->parent=gg;

        if (gg && gg->left==g) gg->left=x;
        else if (gg && gg->right==g) gg->right=x;
    }
    else if (g->right==p && p->left==x) //right rotation; left rotation
    {
        Node *B=x->left;
        Node *C=x->right;

        g->right=B;
        if (B) B->parent=g;
        g->parent=x;

        p->left=C;
        if (C) C->parent=p;
        p->parent=x;

        x->left=g;
        x->right=p;
        x->parent=gg;

        if (gg && gg->left==g) gg->left=x;
        else if (gg && gg->right==g) gg->right=x;
    }
}

void SplayTree::splay (Node *x)
{
    while (x->parent)
    {
        Node *p=x->parent;
        Node *g=p->parent;
        if (!g) zig (x);
        else if (g->left==p && p->left==x) zig_zig (x);
        else if (g->right==p && p->right==x) zig_zig (x);
        else if (g->left==p && p->right==x) zig_zag (x);
        else if (g->right==p && p->left==x) zig_zag (x);
    }

    this->root=x;
}

Node* SplayTree::min (Node *x)
{
    Node *ret=x;
    while (ret->left) ret=ret->left;
    return ret;
}

Node* SplayTree::max (Node *x)
{
    Node *ret=x;
    while (ret->right) ret=ret->right;
    return ret;
}

void SplayTree::insert (int x)
{
    Node *cur=root;

    if (!this->root)
    {
        this->root=new Node(x);
        return;
    }

    while (cur)
    {
        if (x==cur->key)
        {
            splay(cur);
            cur=NIL;
        }
        else if (x<cur->key)
        {
            if (cur->left) cur=cur->left;
            else
            {
                Node *xt=new Node(x);
                cur->left=xt;
                xt->parent=cur;
                splay(xt);
                cur=NIL;
            }
        }
        else
        {
            if (cur->right) cur=cur->right;
            else
            {
                Node *xt=new Node(x);
                cur->right=xt;
                xt->parent=cur;
                splay(xt);
                cur=NIL;
            }
        }
    }
}

Node* SplayTree::find (int x)
{
    Node *ret=NIL;
    Node *cur=this->root;

    while (cur)
    {
        if (x==cur->key)
        {
            ret=cur;
            cur=NIL;
        }
        else if (x>cur->key) cur=cur->right;
        else cur=cur->left;
    }

    if (ret) splay (ret);
    return ret;
}

Node* SplayTree::remove (int x) //to do
{
}

int main()
{
    SplayTree *st=new SplayTree();

    st->insert(1);
    st->insert(100);
    st->insert(25);
    st->insert(3);
    st->insert(5);
    st->insert(7);

    return 0;
}