• 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                   = 0;
    
        for (; i < iSize; i++)
        {
            if (0 == i)
            {
                /* as root */
                if (!aiArr[0]) return NULL;
                pstNode = malloc(sizeof(struct TreeNode));
                memset(pstNode, 0, sizeof(struct TreeNode));
                pstNode->val = aiArr[0];
                pstNode->left = NULL;
                pstNode->right = NULL;
                pstRoot = pstNode;
            }
            else
            {
                if (0 == aiArr[i])
                {
                    continue;
                }
                pstNode =  getNodeByVal(pstRoot, aiArr[i]);
                if (!pstNode) 
                {
                    return NULL;
                }
            }
    
            /* construct child */
            if (iSize >= 2 * (i + 1) - 1)
            {
                if (aiArr[2 * i + 1])
                {
                    pstLeft = malloc(sizeof(struct TreeNode));
                    memset(pstLeft, 0, sizeof(struct TreeNode));
                    pstLeft->val = aiArr[2 * i + 1];
                    pstNode->left = pstLeft;
                }
    
                if ((iSize >= 2 * (i + 1) ) && (aiArr[2 * i + 2]))
                {
                    pstRight = malloc(sizeof(struct TreeNode));
                    memset(pstRight, 0, sizeof(struct TreeNode));
                    pstRight->val = aiArr[2 * i + 2];
                    pstNode->right = pstRight;
                }
            }
        }
        return pstRoot;
    }
    
    /*
     * @ desc:  get binary tree height 
     * @ in  :
     * @ out :
     * @ ret :
     */
    int getBinTreeHeight(struct TreeNode* root)
    {
        int                 iLeftHeight         = 0;
        int                 iRightHeight        = 0;
    
        if (!root) return 0;
    
        if (!root->left && !root->right) return 1;
    
        if (root->left)
        {
            iLeftHeight = getBinTreeHeight(root->left);
        }
    
        if (root->right)
        {
            iRightHeight = getBinTreeHeight(root->right);
        }
        return (MAX_INT(iLeftHeight, iRightHeight) + 1);
    }
    
    /*
     * @ 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             = 0;
        int                 iSize               = 0;
        int                 i                   = 0;
        int                 iStart              = 0;
        struct TreeNode*    pstNode             = NULL;
        
        /* arrsize = 2 ^ iHeight - 1 */
        iHeight = getBinTreeHeight(root);
        if (iHeight > 16) return NULL;
        iSize = (1<<iHeight) - 1;
    
        piOut = malloc(sizeof(int) * iSize + 1);
        memset(piOut, 0, sizeof(int) * iSize + 1);
    
        piOut[0] = root->val;
    
        for (i = 0; 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 * 2 + 1] = pstNode->left->val;
                }
    
                if (pstNode->right)
                {
                    piOut[i * 2 + 2] = pstNode->right->val;
                }
            }
        }
        
        *piSize = iSize;
        return piOut;
        
    error:
        free(piOut); 
        piOut = NULL;
        *piSize = 0;
        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             = 0;
        if (root)
        {
            if (iVal == root->val) return iHeight;
        }
        if (root->left)
        {
            pstNode = getNodeByVal(root->left, iVal);
            if (pstNode) return (getBinNodeHeight(root->left, iVal) + 1);
        }
        if (root->right)
        {
            pstNode = getNodeByVal(root->right, iVal);
            if (pstNode) return (getBinNodeHeight(root->right, iVal) + 1);
        }
        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
  • 相关阅读:
    C# WinForm多线程(一)Thread类库
    ASP.NET执行循序
    SQLSERVER2014的内存优化表
    C# 5.0 Async函数的提示和技巧
    WPF 绑定
    使用 Cordova+Visual Studio 创建跨平台移动应用(3)
    使用 Cordova+Visual Studio 创建跨平台移动应用(2)
    使用 WPF 创建预加载控件
    A WPF/MVVM Countdown Timer
    使用WPF创建无边框窗体
  • 原文地址:https://www.cnblogs.com/ashen/p/10573313.html
Copyright © 2020-2023  润新知