leetcode.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 的整数。

思路与代码

我的代码bfs

#include <vector>
#include <iostream>
#include <queue>

using namespace std;

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:
	queue<TreeNode*> Q;
	int x_parent = -1, y_parent = -1;
	int x_floor = -1, y_floor = -1;
	int floor = 0;
public:
	//993.二叉树的堂兄弟节点
	//bfs
	bool isCousins(TreeNode* root, int x, int y) {
		Q.push(root);
		while (!Q.empty()) {
			int size = Q.size();
			for (int i = 0; i < size; i++) {
				TreeNode* node = Q.front();
				Q.pop();
				if (node->left != nullptr) {
					Q.push(node->left);
					if (x == node->left->val) {
						x_parent = node->val;
						x_floor = floor;
					}
					if (y == node->left->val) {
						y_parent = node->val;
						y_floor = floor;
					}
				}
				if (node->right != nullptr) {
					Q.push(node->right);
					if (x == node->right->val) {
						x_parent = node->val;
						x_floor = floor;
					}
					if (y == node->right->val) {
						y_parent = node->val;
						y_floor = floor;
					}
				}
			}
			floor++;
		}

		if (x_floor == y_floor && x_parent != y_parent) {
			return true;
		}
		return false;
	}
};

int main1()
{
	TreeNode* root = new TreeNode(1);
	TreeNode* root2 = new TreeNode(2);
	TreeNode* root3 = new TreeNode(3);
	TreeNode* root4 = new TreeNode(4);

	root->left = root2;
	root->right = root3;
	root2->left = root4;

	Solution s;
	cout << s.isCousins(root, 4, 3) << endl;
	return 0;
}
//输入：root = [1, 2, 3, 4], x = 4, y = 3
//输出：false



int main2()
{
	TreeNode* root = new TreeNode(1);
	TreeNode* root2 = new TreeNode(2);
	TreeNode* root3 = new TreeNode(3);


	TreeNode* root4 = new TreeNode(4);
	TreeNode* root5 = new TreeNode(5);

	root->left = root2;
	root->right = root3;
	root3->left = root4;
	root3->right = root5;

	Solution s;
	cout << s.isCousins(root, 4, 5) << endl;
	return 0;
}
//[1, 2, 3, null, null, 4, 5]
//4
//5


int main()
{
	TreeNode* root = new TreeNode(1);
	TreeNode* root2 = new TreeNode(2);
	TreeNode* root3 = new TreeNode(3);


	TreeNode* root4 = new TreeNode(4);
	TreeNode* root5 = new TreeNode(5);

	root->left = root2;
	root->right = root3;
	root2->right = root4;
	root3->right = root5;

	Solution s;
	cout << s.isCousins(root, 5, 4) << endl;
	return 0;
}
//[1, 2, 3, null, 4, null, 5]
//5
//4

官方的代码bfs

class Solution {
private:
    // x 的信息
    int x;
    TreeNode* x_parent;
    int x_depth;
    bool x_found = false;

    // y 的信息
    int y;
    TreeNode* y_parent;
    int y_depth;
    bool y_found = false;

public:
    // 用来判断是否遍历到 x 或 y 的辅助函数
    void update(TreeNode* node, TreeNode* parent, int depth) {
        if (node->val == x) {
            tie(x_parent, x_depth, x_found) = tuple{parent, depth, true};
        }
        else if (node->val == y) {
            tie(y_parent, y_depth, y_found) = tuple{parent, depth, true};
        }
    }

    bool isCousins(TreeNode* root, int x, int y) {
        this->x = x;
        this->y = y;
        queue<pair<TreeNode*, int>> q;
        q.emplace(root, 0);
        update(root, nullptr, 0);

        while (!q.empty()) {
            auto&& [node, depth] = q.front();
            if (node->left) {
                q.emplace(node->left, depth + 1);
                update(node->left, node, depth + 1);
            }
            if (node->right) {
                q.emplace(node->right, depth + 1);
                update(node->right, node, depth + 1);
            }
            if (x_found && y_found) {
                break;
            }
            q.pop();
        }

        return x_depth == y_depth && x_parent != y_parent;
    }
};