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:
- The number of nodes in the tree will be between
2
and100
. - Each node has a unique integer value from
1
to100
.
/* * @ 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