HackerRank "Self Balancing Tree"

node *create_node(int val)
{
node *pNew = new node;
pNew->val = val;
pNew->ht  = 0;
pNew->left = pNew->right = nullptr;

return pNew;
}

int height(node *p)
{
if(!p) return -1;
return p->ht;
}

int get_height(node *p)
{
if (!p) return 0;
return 1 + max(height(p->left), height(p->right));
}

node *right_rotate(node *p)
{
node *pOrigRoot = p;
node *root = p->left;
pOrigRoot->left = root->right;
root->right = pOrigRoot;

pOrigRoot->ht = get_height(pOrigRoot);
root->ht = get_height(root);

return root;
}

node *left_rotate(node *p)
{
node *pOrigRoot = p;
node *root = p->right;
pOrigRoot->right = root->left;
root->left = pOrigRoot;

pOrigRoot->ht = get_height(pOrigRoot);
root->ht = get_height(root);

return root;
}

int balance_factor(node *p)
{
if (!p) return 0;
return height(p->left) - height(p->right);
}

node *balance(node *p)
{
int w = balance_factor(p);

if (!p || abs(w) < 2)
return p;

if (w > 0)
{
if(balance_factor(p->left) < 0)
{
p->left = left_rotate(p->left);
}
return right_rotate(p);
}
else
{
if(balance_factor(p->right) > 0)
{
p->right = right_rotate(p->right);
}
return left_rotate(p);
}

return p;
}

node * insert(node * root,int val)
{
if (val < root->val)
{
if(!root->left)
{
root->left = create_node(val);
}
else
{
root->left = insert(root->left, val);
}
}
else
{
if(!root->right)
{
root->right = create_node(val);
}
else
{
root->right = insert(root->right, val);
}
}
root->ht = get_height(root);

return balance(root);
}