872. 叶子相似的树

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

示例 1：

输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出：true

示例 2：

输入：root1 = [1], root2 = [1]
输出：true

示例 3：

输入：root1 = [1], root2 = [2]
输出：false

示例 4：

输入：root1 = [1,2], root2 = [2,2]
输出：true

示例 5：

输入：root1 = [1,2,3], root2 = [1,3,2]
输出：false

代码与思路

#include <vector>
#include <iostream>
#include <string>
#include <deque>

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 {
public:
	void dfs(TreeNode* node, vector<int>& seq) {
		if (!node->left && !node->right) {
			seq.push_back(node->val);
		}
		else {
			if (node->left) {
				dfs(node->left, seq);
			}
			if (node->right) {
				dfs(node->right, seq);
			}
		}
	}
	//递归
	bool leafSimilar(TreeNode* root1, TreeNode* root2) {
		vector<int> seq1;
		if (root1) {
			dfs(root1, seq1);
		}

		vector<int> seq2;
		if (root2) {
			dfs(root2, seq2);
		}

		return seq1 == seq2;
	}

	void process(TreeNode* root, vector<int>& seq) {
		deque<TreeNode*> st;
		while (root != nullptr || !st.empty()) {
			while (root != nullptr) {
				st.push_back(root);
				root = root->left;
			}
			root = st.back();
			st.pop_back();
			if (root->left == nullptr && root->right == nullptr) seq.push_back(root->val);
			root = root->right;
		}
	}

	//迭代
	bool leafSimilar2(TreeNode* root1, TreeNode* root2) {
		vector<int> seq1;
		process(root1, seq1);
		vector<int> seq2;
		process(root2, seq2);
		return seq1 == seq2;
	}
};

int main()
{
	TreeNode* node1 = new TreeNode(1);
	TreeNode* node2 = new TreeNode(1);
	Solution s;
	cout << s.leafSimilar2(node1, node2) << endl;

}

递归，找左叶子节点，找右叶子节点，放入序列中，然后比较序列。
迭代，使用栈来模拟递归过程，也属于树的遍历中的常见实现形式。