文档讲解
层序遍历 递归遍历 BFS DFS
思路:层序遍历的关键在于把每一层的节点存入一个队列中,并且此时这个代码是从左到右遍历的(注意遍历顺序)
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
queue<TreeNode*> que;
if(root!=nullptr) que.push(root);
while(!que.empty())
{
int size=que.size();
vector<int> vec;
while(size--)
{
TreeNode* node=que.front();
que.pop();
vec.push_back(node->val);
if(node->left)que.push(node->left);
if(node->right)que.push(node->right);
}
result.push_back(vec);
}
return result;
}
};
226. 翻转二叉树
递归法:
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root==nullptr)return root;
swap(root->left,root->right);
if(root->left)invertTree(root->left);
if(root->right)invertTree(root->right);
return root;
}
};
迭代法:
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root==nullptr)return root;
queue<TreeNode*> que;
que.push(root);
while(!que.empty())
{
int size=que.size();
while(size--)
{
TreeNode* node=que.front();
que.pop();
swap(node->left,node->right);
if(node->left)que.push(node->left);
if(node->right)que.push(node->right);
}
}
return root;
}
};
思路:为什么使用统一的中序迭代法是可以用于本题的呢?因为是从叶子节点自顶向上回溯,我们使用中序遍历的问题在于,因为我们是访问过一个子节点,再访问其父亲节点,若这样的话在父亲节点的时候将两个子节点的位置进行交换,第二次访问另外一个子节点的时候,又会访问到上一个子节点,故报错!
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
stack<TreeNode*> st;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* node = st.top();
if (node != NULL) {
st.pop();
if (node->right) st.push(node->right); // 右
st.push(node); // 中
st.push(NULL);
if (node->left) st.push(node->left); // 左
} else {
st.pop();
node = st.top();
st.pop();
swap(node->left, node->right); // 节点处理逻辑
}
}
return root;
}
};
class Solution {
public:
bool isSymmetric(TreeNode* root) {
queue<TreeNode*>que;
if(root==nullptr)return true;
que.push(root->left);
que.push(root->right);
while(!que.empty())
{
TreeNode* LeftNode=que.front();
que.pop();
TreeNode* RightNode=que.front();
que.pop();
if(!LeftNode&&!RightNode)
{
continue;
}
if((!LeftNode&&RightNode)||(LeftNode&&!RightNode)||(LeftNode->val!=RightNode->val))
{
return false;
}
que.push(LeftNode->left);
que.push(RightNode->right);
que.push(RightNode->left);
que.push(LeftNode->right);
}
return true;
}
};
递归法:
class Solution {
public:
bool issameTree(TreeNode* p,TreeNode* q)
{
if(p==nullptr||q==nullptr)
{
return p==q;
}
return p->val==q->val&&issameTree(p->left,q->right)&&issameTree(p->right,q->left);
}
bool isSymmetric(TreeNode* root) {
return issameTree(root->left,root->right);
}
};