AVL tree implementation

//solution of a Hakerearth problem

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
struct Node 
{ 
    int data; 
    struct Node *left; 
    struct Node *right; 
    int height; 
};

struct Node* insert(struct Node* , int data,int k) ;
struct Node *rightrotate(struct Node *y) ;
struct Node *leftrotate(struct Node *y) ;
int balance(struct Node *root) ;
int height(struct Node *root) ;
struct Node* delete_node(struct Node* root, int data,int k) ;
struct Node* createnode(int key) ;
struct Node * min_node(struct Node* root) ;
Node* search(Node *root,int data);
int max(int a, int b); 
void inorder_traversal(Node *root);

int left_rot=0,right_rot=0;
int left_mov=0,right_mov=0;

int main() {
    struct Node *root = NULL; 
    Node *temp=NULL;
    int k,q,data,ch;
    cin>>k;
    cin>>q;
    for(int i=0;i<q;i++)
    {
        cin>>ch;
        switch(ch)
        {
            case 1:
                cin>>data;
                root=insert(root,data,k); 
                break;
            case 2:cout<<left_rot<<" "<<right_rot<<endl;
                break;
            case 3:
                cin>>data;
                 left_mov=0;
                 right_mov=0;
                 temp=search(root,data);
                if(temp==NULL)
                    cout<<"-1 -1"<<endl;
                else
                    cout<<left_mov<<" "<<right_mov<<endl;
                break;
            case 4:cin>>data;
                root= delete_node(root, data,k) ;
                break;
            case 5:inorder_traversal(root);
                cout<<endl;
                break;
        }
    }
    return 0;
}
struct Node* insert(struct Node* root, int data,int k)
{
    if(root==NULL)
    {
       root=createnode(data);
       return root;
    }
    
    if(data<=root->data)
    {
       root->left=insert(root->left,data,k);
    }
    else 
    {
       root->right=insert(root->right,data,k);
    }
    
    root->height=1+max(height(root->left),height(root->right));
    
    int bal_f=balance(root);
    
    if(k<bal_f && data<root->left->data)
    {
        return rightrotate(root);
    }
    if(-k>bal_f && data>root->right->data)
    {
        return leftrotate(root);    
    }
    if (bal_f > k && data > root->left->data) 
    { 
        root->left =  leftrotate(root->left); 
        return rightrotate(root); 
    }
    if (bal_f < -k && data < root->right->data) 
    { 
        root->right = rightrotate(root->right); 
        return leftrotate(root); 
    } 
    return root;   
}

struct Node* createnode(int data) 
{
    Node *p=new Node;
    p->left=NULL;
    p->right=NULL;
    p->height=1;
    p->data=data;
    return p;
}

int balance(struct Node *root) 
{
    if(root==NULL)
      return 0;
    return (height(root->left)-height(root->right));
}
int height(struct Node *N) 
{ 
    if (N == NULL) 
        return 0; 
    return N->height; 
} 

int max(int a, int b)
{
    if(a>b)
      return a;
    else 
      return b;
}

struct Node *rightrotate(struct Node *y) 
{
    right_rot++;
    
    Node *x=y->left;
   // Node *t=y->right;
    
    y->left=x->right;
    x->right=y;
    
    y->height = max(height(y->left), height(y->right))+1; 
    x->height = max(height(x->left), height(x->right))+1;   
    return x;  
}

struct Node *leftrotate(struct Node *y) 
{
    left_rot++;
    // Node *z=y->left;
    Node *x=y->right;
    
    y->right=x->left;
    x->left=y;
    
    y->height = max(height(y->left), height(y->right))+1; 
    x->height = max(height(x->left), height(x->right))+1;   
    return x;  
}

Node *search(Node *root,int data)
{
    if(root->data==data || root==NULL)
    {
        return root;
    }
    if(data<root->data)
    {
        left_mov++;
        return search(root->left, data);
    }
    else
    {
        right_mov++;
        return search(root->right, data);    
    }   
}
void inorder_traversal(Node *root)
{
    if(root==NULL)
    {
        return;
    }
    inorder_traversal(root->left);
    cout<<root->data;
    inorder_traversal(root->right);
}

struct Node * min_node(struct Node* root) 
{ 
    struct Node* p = root; 
    while (p->left != NULL) 
        p = p->left; 
  
    return p;
}

struct Node* delete_node(struct Node* root, int data,int k) 
{
    if(root==NULL)
      return root;
    if(data<root->data)
        root->left=delete_node(root->left,data,k);
    else if(data>root->data)
        root->right=delete_node(root->right,data,k);
    else
    {
        if(root->left==NULL||root->right==NULL)
        {
           if(root->left==NULL)
              return root->right;
           else 
              return root->left;
        }
        else
        {
            Node *p=min_node(root->right);
            root->data=p->data;
            delete_node(root->right,p->data,k);
        }
    } 
    if(root==NULL)
      return root;
    root->height=1+max(height(root->left),height(root->right));
    
    int bal_f=balance(root);
    
    if(k<bal_f && data<root->left->data)
    {
        return rightrotate(root);
    }
    if(-k>bal_f && data>root->right->data)
    {
        return leftrotate(root);    
    }
    if (bal_f > k && data > root->left->data) 
    { 
        root->left =  leftrotate(root->left); 
        return rightrotate(root); 
    }
    if (bal_f < -k && data < root->right->data) 
    { 
        root->right = rightrotate(root->right); 
        return leftrotate(root); 
    } 
    return root;    
}