层序遍历
看完本篇可以一口气刷十道题
题目链接/文章讲解/视频讲解
队列先进先出,符合一层一层遍历的逻辑,而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历,只不过我们应用在二叉树上。
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
queue<TreeNode*> queue;
if(root != nullptr) {
queue.push(root);//空节点不入队列
}
while(!queue.empty()) {
vector<int> vec;
int size = queue.size();
//循环获取每一层的节点
while(size --) {
TreeNode* node = queue.front();
queue.pop();
vec.push_back(node->val);
if(node->left != nullptr) {
queue.push(node->left);//空节点不入队列
}
if(node->right != nullptr) {
queue.push(node->right);//空节点不入队列
}
}
//将每一层的结果加入返回值
result.push_back(vec);
}
return result;
}
};
226.翻转二叉树 (优先掌握递归)
leetcode题目链接
题目链接/文章讲解/视频讲解:https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html
//先序遍历 反转
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root == nullptr) return root;
swap(root->left, root->right);//当前节点的处理
invertTree(root->left);//处理左子树
invertTree(root->right);//处理右子树
return root;
}
};
- 对称二叉树
题目链接/文章讲解/视频讲解
重点:
同时遍历两颗二叉树,看两个二叉树是否可以左右翻转
判断逻辑:
使用后序遍历,判断两个数的子节点是否是对称的,将结果返回给父节点
判断是否可以反转就是判断,两颗树的外侧节点和内侧节点是否都相等
//递归遍历
class Solution {
public:
bool compare(TreeNode* left, TreeNode* right) {
// 首先排除空节点的情况
if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
// 排除了空节点,再排除数值不相同的情况
else if (left->val != right->val) return false;
// 此时就是:左右节点都不为空,且数值相同的情况
// 此时才做递归,做下一层的判断
bool outside = compare(left->left, right->right); // 左子树:左、 右子树:右
bool inside = compare(left->right, right->left); // 左子树:右、 右子树:左
bool isSame = outside && inside; // 左子树:中、 右子树:中 (逻辑处理)
return isSame;
}
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
return compare(root->left, root->right);
}
};
//迭代法
//使用队列,遍历左右两棵树,注意入队列的顺序,两个外侧入队列后,内侧如队列。
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
queue<TreeNode*> que;
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;
}
// 左右一个节点不为空,或者都不为空但数值不相同,返回false
if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
return false;
}
que.push(leftNode->left); // 加入左节点左孩子
que.push(rightNode->right); // 加入右节点右孩子
que.push(leftNode->right); // 加入左节点右孩子
que.push(rightNode->left); // 加入右节点左孩子
}
return true;
}
};
//迭代法使用栈
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
stack<TreeNode*> st; // 这里改成了栈
st.push(root->left);
st.push(root->right);
while (!st.empty()) {
TreeNode* leftNode = st.top(); st.pop();
TreeNode* rightNode = st.top(); st.pop();
if (!leftNode && !rightNode) {
continue;
}
if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
return false;
}
st.push(leftNode->left);
st.push(rightNode->right);
st.push(leftNode->right);
st.push(rightNode->left);
}
return true;
}