力扣每日一题：993. 二叉树的堂兄弟节点

题目：993. 二叉树的堂兄弟节点

难度： 简单

题目：
在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。

如果二叉树的两个节点深度相同，但 父节点不同 ，则它们是一对堂兄弟节点。

我们给出了具有唯一值的二叉树的根节点 root ，以及树中两个不同节点的值 x 和 y 。

只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true 。否则，返回 false。

示例1

输入：root = [1,2,3,4], x = 4, y = 3
输出：false

示例2

输入：root = [1,2,3,null,4,null,5], x = 5, y = 4
输出：true

示例3

输入：root = [1,2,3,null,4], x = 2, y = 3
输出：false

提示：

• 二叉树的节点数介于 2 到 100 之间。
• 每个节点的值都是唯一的、范围为 1 到 100 的整数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cousins-in-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

  寻找二叉树的堂兄弟结点，根本在于：同一层，且父结点不同。

解题代码

（1）层序遍历（BFS）

  采用队列实现二叉树的层序遍历，那么我们每次都对同一层进行遍历，而也只有同一层才存在堂兄弟结点。在一次同层的遍历中，找到等于x，等于y的两个节点，为了辨别是否为堂兄弟结点，那么我们可以加入一个空节点，值为-1，每个父结点的子节点之间利用-1来分割，就可以识别是否为父子结点了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        
        //层序遍历
        queue<TreeNode*> que;
        que.push(root);
        int level = 0;

        while (!que.empty())
        {
            int n = que.size();
            bool flag = false;
            bool start = false;
            bool end = false;
            cout<<n<<endl;
            for (int i = 0; i < n; i++)
            {
                TreeNode* tmp = que.front();
                int value = tmp->val;
                que.pop();
                if (value == x || value == y)
                {
                    if (start)//开始
                    {
                        if (end == true)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        start = true;
                    }
                }
                if (start)
                {
                    if (value == -1)
                    {
                        end = true;
                    }
                }

                if (value != -1)
                {
                    TreeNode* node = new TreeNode(-1);
                    que.push(node);//作为表示分界线
                    if (tmp->left)
                    {
                        que.push(tmp->left);
                    }
                    if (tmp->right)
                    {
                        que.push(tmp->right);
                    }
                }
                
            }
            
        }
        return false;

    }
};

（2）先序遍历（DFS）

  先序遍历从根节点开始，遍历左子树和右子树，也是不断地从上往下遍历，而且比起层序遍历，能否更好得处理父结点的问题。可以加两个标志剪枝。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    int xlevel, ylevel;
    TreeNode* xpre, *ypre;
public:
    bool isCousins(TreeNode* root, int x, int y) {
        
        xlevel = -1;
        ylevel = -1;
        xpre = nullptr;
        ypre = nullptr;

        DFS(root, x, y, 0, nullptr);
        cout << xlevel << " " << ylevel << endl;
        return xlevel == ylevel && xpre != ypre;

    }

    void DFS(TreeNode* root, int x, int y, int level, TreeNode* pre)
    {
        if (!root) return;
        if (root->val == x)
        {
            xlevel = level;
            xpre = pre;
        }
        if (root->val == y)
        {
            ylevel = level;
            ypre = pre;
        }

        DFS(root->left, x, y, level + 1, root);
        DFS(root->right, x, y, level + 1, root);
    }
};