leetCode笔记--binary tree

993. Cousins in Binary Tree

In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.

Two nodes of a binary tree are cousins if they have the same depth, but have different parents.

We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree.

Return true if and only if the nodes corresponding to the values x and y are cousins.

Example 1:

Input: root = [1,2,3,4], x = 4, y = 3
Output: false

Example 2:

Input: root = [1,2,3,null,4,null,5], x = 5, y = 4
Output: true

Example 3:

Input: root = [1,2,3,null,4], x = 2, y = 3
Output: false

Note:

1. The number of nodes in the tree will be between 2 and 100.
2. Each node has a unique integer value from 1 to 100.

/*
 * @ desc: initBinaryTree
 * @ in  :
 *          aiArr
 *          iSize
 * @ out :
 *         target binary tree
 * @ cautious :
 *  n pos in arr
 *  child pos is 2n + 1, 2n + 2
 *
 *          0
 *      1       2
 *    3   4   5   6
 *  ...
 *  Child poionter is null that arr value is 0.
 *  ele in aiArr is different.
 */
struct TreeNode* initBinaryTree(int aiArr[], int iSize)
{
    struct TreeNode *pstNode            = NULL;
    struct TreeNode *pstLeft            = NULL;
    struct TreeNode *pstRight           = NULL;
    struct TreeNode *pstRoot            = NULL;
    int             i                   = ;
 
    for (; i < iSize; i++)
    {
        if ( == i)
        {
            /* as root */
            if (!aiArr[]) return NULL;
            pstNode = malloc(sizeof(struct TreeNode));
            memset(pstNode, , sizeof(struct TreeNode));
            pstNode->val = aiArr[];
            pstNode->left = NULL;
            pstNode->right = NULL;
            pstRoot = pstNode;
        }
        else
        {
            if ( == aiArr[i])
            {
                continue;
            }
            pstNode =  getNodeByVal(pstRoot, aiArr[i]);
            if (!pstNode)
            {
                return NULL;
            }
        }
 
        /* construct child */
        if (iSize >=  * (i + ) - )
        {
            if (aiArr[ * i + ])
            {
                pstLeft = malloc(sizeof(struct TreeNode));
                memset(pstLeft, , sizeof(struct TreeNode));
                pstLeft->val = aiArr[ * i + ];
                pstNode->left = pstLeft;
            }
 
            if ((iSize >=  * (i + ) ) && (aiArr[ * i + ]))
            {
                pstRight = malloc(sizeof(struct TreeNode));
                memset(pstRight, , sizeof(struct TreeNode));
                pstRight->val = aiArr[ * i + ];
                pstNode->right = pstRight;
            }
        }
    }
    return pstRoot;
}
 
/*
 * @ desc:  get binary tree height
 * @ in  :
 * @ out :
 * @ ret :
 */
int getBinTreeHeight(struct TreeNode* root)
{
    int                 iLeftHeight         = ;
    int                 iRightHeight        = ;
 
    if (!root) return ;
 
    if (!root->left && !root->right) return ;
 
    if (root->left)
    {
        iLeftHeight = getBinTreeHeight(root->left);
    }
 
    if (root->right)
    {
        iRightHeight = getBinTreeHeight(root->right);
    }
    return (MAX_INT(iLeftHeight, iRightHeight) + );
}
 
/*
 * @ desc: deserialization binary tree to arr
 * @ in  :
 *          root        in_tree
 * @ out :
 *          iSize       arrSize
 * @ ret :
 *          outPutArr
 */
int* deserialBinTree(struct TreeNode* root, int* piSize)
{
    int*                piOut               = NULL;
    int                 iHeight             = ;
    int                 iSize               = ;
    int                 i                   = ;
    int                 iStart              = ;
    struct TreeNode*    pstNode             = NULL;
 
    /* arrsize = 2 ^ iHeight - 1 */
    iHeight = getBinTreeHeight(root);
    if (iHeight > ) return NULL;
    iSize = (<<iHeight) - ;
 
    piOut = malloc(sizeof(int) * iSize + );
    memset(piOut, , sizeof(int) * iSize + );
 
    piOut[] = root->val;
 
    for (i = ; i <= iSize; i++)
    {
        if (piOut[i])
        {
            pstNode = getNodeByVal(root, piOut[i]);
            if (!pstNode)
            {
                goto error;
            }
            /* set val in arr by index */
            if (pstNode->left)
            {
                piOut[i *  + ] = pstNode->left->val;
            }
 
            if (pstNode->right)
            {
                piOut[i *  + ] = pstNode->right->val;
            }
        }
    }
 
    *piSize = iSize;
    return piOut;
 
error:
    free(piOut);
    piOut = NULL;
    *piSize = ;
    return NULL;
}
 
struct TreeNode* getBinNodeParent(struct TreeNode* root, int iVal)
{
    struct TreeNode*    pstNode             = NULL;
    if (!root || (iVal == root->val))
    {
        return NULL;
    }
 
    if (root->left)
    {
        if (iVal == root->left->val) return root;
        pstNode = getBinNodeParent(root->left, iVal);
        if (pstNode) return pstNode;
        pstNode = getBinNodeParent(root->right, iVal);
        if (pstNode) return pstNode;
    }
    if (root->right)
    {
        if (iVal == root->right->val) return root;
        pstNode = getBinNodeParent(root->left, iVal);
        if (pstNode) return pstNode;
        pstNode = getBinNodeParent(root->right, iVal);
        if (pstNode) return pstNode;
    }
    return pstNode;
}
int getBinNodeHeight(struct TreeNode* root, int iVal)
{
    struct TreeNode*    pstNode             = NULL;
    int                 iHeight             = ;
    if (root)
    {
        if (iVal == root->val) return iHeight;
    }
    if (root->left)
    {
        pstNode = getNodeByVal(root->left, iVal);
        if (pstNode) return (getBinNodeHeight(root->left, iVal) + );
    }
    if (root->right)
    {
        pstNode = getNodeByVal(root->right, iVal);
        if (pstNode) return (getBinNodeHeight(root->right, iVal) + );
    }
    return iHeight;
 
}
struct TreeNode* getNodeByVal(struct TreeNode* root, int iVal)
{
    struct TreeNode*    pstNode             = NULL;
    if (root)
    {
        if (iVal == root->val) return root;
    }
    if (root->left)
    {
        pstNode = getNodeByVal(root->left, iVal);
        if (pstNode) return pstNode;
    }
    if (root->right)
    {
        pstNode = getNodeByVal(root->right, iVal);
        if (pstNode) return pstNode;
    }
    return pstNode;
 
}
 
struct TreeNode* postTravel(struct TreeNode* root)
{
    if (root->left) postTravel(root->left);
    if (root->right) postTravel(root->right);
    printf("%d ", root->val);
    return root;
}
struct TreeNode* getFistNodeByPostTravel(struct TreeNode* pstRoot)
{
    return NULL;
}
struct TreeNode* getNextByPostTravel(struct TreeNode* pstRoot)
{
    struct TreeNode*    pstParentNode   = NULL;
    if (pstRoot->left) return pstRoot->left;
    if (pstRoot->right) postTravel(pstRoot->right);
    pstParentNode = getBinNodeParent(pstRoot, pstRoot->val);
    if (!pstParentNode) return NULL;
    return getNextByPostTravel(pstParentNode);
}
#endif