LeetCode "Lowest Common Ancestor of a BST"

class Solution 
{
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        if(!root) return nullptr;
        int sm = std::min(p->val, q->val);
        int lg = std::max(p->val, q->val);
        
        if( (root->val > sm && root->val < lg) || (root->val == sm || root->val == lg))
            return root;
        else if(root->val > lg)    
            return lowestCommonAncestor(root->left, p, q);
        else if(root->val < sm)
            return lowestCommonAncestor(root->right, p, q);
        return nullptr;
    }
};

// unsigend char as record
typedef unsigned char uchar;
class Solution 
{
    TreeNode *pret;
    uchar go(TreeNode *root, TreeNode* p, TreeNode *q)
    {
        if (!root) return 0;
        uchar rec = 0;

        rec |= (root == p) ? 0x1 : 0;
        rec |= (root == q) ? 0x2 : 0;

        uchar rleft = go(root->left, p, q);
        if(rleft ==0x3)
        {
            return 0x3;
        }
        if (rec && ((rec | rleft) == 0x3))
        {
            pret = root;
            return 0x3;
        }

        uchar rright= go(root->right, p, q);
        if(rright ==0x3) return 0x3;
        if (rec && ((rec | rright) == 0x3))
        {
            pret = root;
            return 0x3;
        }

        if ((rleft | rright )== 0x3)
        {
            pret = root;
        }

        return rec | rleft | rright;
    }
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        pret = nullptr;
        go(root, p, q);
        return pret;
    }
};