本文介绍了四道关于二叉树的算法题，包括填充每个节点的下一个右侧节点指针、求二叉树的最小深度、翻转二叉树以及判断对称二叉树的问题。解题方法主要涉及递归和迭代的层序遍历，通过比较节点和调整子树结构来实现相应功能。
算法学习记录| 2023.X.XX| XXXXDayX| 题目号.题目标题 & 题目号.题目标题
116.填充每个节点的下一个右侧节点指针
题目链接
思路
具体思路和层序遍历相同。主要需要设置一个pre节点，通过循环来将pre节点的next节点设为当前节点，以满足题目要求
代码
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != NULL)
que.push(root);
while(!que.empty()){
int size = que.size();
Node* nodepre; //用于记录前一个节点
Node* node; //nodepre -> next就是node
for (int i = 0; i < size; i++){
if( i == 0){
nodepre = que.front(); //第一个节点需要特殊处理
node = que.front();
que.pop();
}
else{
node = que.front();
que.pop();
nodepre -> next = node; //这样上一个节点的next就确定了
nodepre = node; //将pre节点设为当前节点供下一节点使用
}
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
nodepre -> next = NULL; //本层最后一个节点指向NULL(默认也是NULL，所以可不写）
}
return root;
}
};
总结
next关系则可以同时考虑保存前一状态，以与当前状态构建联系。
本质考察的还是层序遍历
111.二叉树的最小深度
题目链接
思路
仍然是层序遍历。
本题特殊要求的思路是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点。
同时需要注意退出条件，因为涉及两层循环嵌套，所以应该直接return结果，而不能用break
代码
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que; //使用队列来保存节点
int count = 0; //记录层数
if ( root!= NULL ) que.push(root);
if ( root == NULL ) return 0;
while(!que.empty()){ //一层一层处理
int size = que.size(); //记录当前层的节点个数
count++;
for (int i = 0; i < size; i++){
TreeNode* node =que.front(); //每处理完当前层的一个节点就pop掉
que.pop();
if (node -> left) //判断当前处理的节点是否有子节点，如果有则加入队列，也就是加入到下一层
que.push(node -> left);
if (node -> right)
que.push(node -> right);
if (node -> left == NULL && node -> right == NULL) //左右子节点都为空时则为最小层数
return count; //不能用break，否则count还会在while里持续增加
}
}
return count;
}
};
总结
226.翻转二叉树
题目链接
思路
其实只要把每个节点的左右子节点交换即可。
前序遍历和后序遍历都可以，但中序遍历会把某些节点的左右节点反转两次，因此不可。
层序遍历也可。
代码1: 递归法（前序遍历）
class Solution {
public:
TreeNode* invertTree(TreeNode* node) {
if ( node == NULL )
return node;
swap(node -> left, node -> right); //中
invertTree(node -> left); //左
invertTree(node -> right); //右
return node;
}
};
代码2：迭代法（前序遍历统一写法）
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); //右
if (node->left) st.push(node -> left); //左
st.push(node); //中
st.push(NULL);
}
else{ //处理所有节点
st.pop();
node = st.top();
swap(node -> left, node -> right); //节点处理逻辑
st.pop();
}
}
return root;
}
};
代码3：层序遍历
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if( root != NULL )
que.push(root);
while(!que.empty()){
int size = que.size();
for( int i = 0; i < size; i++){
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;
}
};
总结
本题其实考察的就是二叉树的基础遍历方式
101. 对称二叉树
题目链接
思路
对称，其实比较的就是根节点的左右子树，需要同时遍历两棵树。
具体比较的就是两个子树的里侧和外侧的元素是否相等。
本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等，准确来说一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。
代码1：递归法
仍然是按照递归三部曲：
- 确定递归函数的参数和返回值：
因为通过比较根节点的两个子树是否为互相反转进而判断整个树是否对称，因此参数就是左子树节点和右子树节点，返回值为bool。
bool compare( TreeNode* left, TreeNode* right )
-
确定终止条件
需要比较两个节点的数值，就得考虑数值可能有哪些情况。首先需要把空指针的情况全都考虑到，这样才能在比较数值的时候不会被空指针影响到。空指针为空的情况有：
- 左节点为空，右节点不为空，return false
- 左节点不为空，右节点为空，return false
- 左右都为空，return true
左右节点都不为空时，比较节点数值。
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;
除了这些情况，就剩下左右节点都不为空且数值相同的情况。这样才能开启递归，开始下一层的判断
- 确定单层递归的逻辑
也就是处理左右节点都不为空且数值相同的情况下，后续如何处理。
- 比较二叉树外侧是否对称：传入左节点的左子节点和右节点的右子节点
- 比较内侧是否对称：传入左节点的右子节点和右节点的左子节点
- 内外侧都对称则返回true，否则false
bool outside = compare(left->left, right->right); // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left); // 左子树：右、 右子树：左
bool isSame = outside && inside; // 左子树：中、 右子树：中（逻辑处理）
return isSame;
因此递归整体代码为
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 inside = compare(left -> right, right -> left); //比较内侧
bool outside = compare(left -> left, right -> right); //比较外侧
bool isSame = inside && outside;
return isSame;
}
bool isSymmetric(TreeNode* root){
if ( root == NULL)
return true;
return compare(root -> left, root -> right);
}
};
代码2：迭代法-使用队列
通过队列来判断根节点的左子树和右子树的内侧和外侧是否相等。
条件判断和递归的逻辑是一样的。
只需要将需要成对处理的节点同时成对加入队列中即可。
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* nodeleft = que.front();
que.pop();
TreeNode* noderight = que.front();
que.pop();
if (nodeleft != NULL && noderight == NULL)
return false;
else if (nodeleft == NULL && noderight != NULL)
return false;
else if (nodeleft ==NULL && noderight == NULL)
continue; //如果是return true则会错误，为什么？
else if ( nodeleft -> val != noderight -> val)
return false;
que.push(nodeleft -> left); //外侧
que.push(noderight -> right);
que.push(nodeleft -> right); //内侧
que.push(noderight -> left);
}
return true;
}
};
其中else if (nodeleft ==NULL && noderight == NULL)如果不用continue而用return true为什么会结果错误？
代码3：迭代法-使用栈
和队列完全一致，因为根本解题思路是把需要处理的元素成对同时放入容器。
因此代码略。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
