leetcode.二叉树

199.二叉树的右视图

法一. BFS

class Solution {
public:
	vector<int>res;
	vector<int> rightSideView(TreeNode* root) {
		if (!root)
			return res;
		queue<TreeNode*>q;
		q.push(root);
		while (!q.empty()) {
			int sz = q.size();
			for (int i = 0; i < sz; ++i) {
				auto top = q.front();
				if (top->left)
					q.push(top->left);
				if (top->right)
					q.push(top->right);
				q.pop();
				if (i == sz - 1)
					res.push_back(top->val);
			}
		}
		return res;

	}
};

法二. DFS(0ms)

class Solution {
public:
	vector<int>res;
	vector<int> rightSideView(TreeNode* root) {
		if (!root)
			return res;
		dfs(root, 0);//从根节点开始访问，根节点深度是0
		return res;

	}
	void dfs(TreeNode* root, int depth) {
		if (!root)
			return;
		// 如果当前节点所在深度还没有出现在res里，说明在该深度下当前节点是第一个被访问的节点，因此将当前节点加入res中。
		if (res.size() == depth)
			res.push_back(root->val);
		dfs(root->right, depth + 1);
		dfs(root->left, depth + 1);
	}
};

572.另一个数的子树

复杂度

class Solution {
public:
    //对s数的每一个节点调用isSameTree函数
	bool isSubtree(TreeNode* s, TreeNode* t) {
		if (s == nullptr && t == nullptr)
			return true;
		if (s == nullptr || t == nullptr)
			return false;
		if (isSameTree(s, t))
			return true;
		return isSubtree(s->left, t) or isSubtree(s->right, t);

			
	}
    //同100题代码，判断两个树是否相等
	bool isSameTree(TreeNode* p, TreeNode* q) {
		if (p == nullptr && q == nullptr)
			return true;
		if (p == nullptr || q == nullptr)
			return false;
		if (p->val != q->val)
			return false;
		return isSameTree(q->left, p->left) && isSameTree(q->right, p->right);
	}
};

236.二叉树的最近公共祖先

class Solution {
public:
    TreeNode* ans;
    bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) return false;
        bool lson = dfs(root->left, p, q);
        bool rson = dfs(root->right, p, q);
        if ((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson))) {
            ans = root;
        } 
        return lson || rson || (root->val == p->val || root->val == q->val);
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return ans;
    }
};

235.二叉搜索树的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* t = root;
        while(t) {
            if( t->val > p->val  && t->val > q->val  ) t = t->left;
            else if(t->val < p->val  && t->val < q->val ) t = t->right;
            else return t;
        }
        return 0;
    }
};