题目1:101.对称二叉树
要判断一个二叉树是否对称,首先要判断两个子树的根节点是否相等,然后判断子树的子树是否相等,
可以理解为比较的是根节点的左右子树是否相互翻转
解法一:递归法
这一题代码随想录的逻辑是非常清晰的,通过比较两个子树的里侧和外侧的元素是否相等
左子树的遍历顺序应该是左右中,右子树的遍历顺序为右左中。
首先排除空节点的情况:
1.左节点为空、右节点不为空
2.左节点不为空、右节点为空
3.左右节点都为空
当左右节点都不为空时,又有两种情况:
1.左右节点指向的值不等
2.左右节点指向的值相等
当左右节点指向的值相等时:
1.比较二叉树外侧是否对称:传入的是左节点的左孩子,右节点的右孩子
2.比较内侧是否对称:传入左节点的右孩子,右节点的左孩子
3.如果左右都对称就返回true ,有一侧不对称就返回false
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; //左节点指向的值不等与右节点指向的值
else { //左右节点指向的值相等,递归
//下边可以简化为 return compare(left->left,right->right) && compare(left->left, right->right);
bool ouside = compare(left->left, right->right); //判断左子树的左孩子与右子树的右孩子是否相等
bool inside = compare(left->left, right->right); //判断左子树的右孩子与右子树的左孩子是否相等
bool issame = ouside && inside; //判断左右子树是否相等
return issame;
}
}
bool isSymmetric(TreeNode* root) {
if (root == NULL) return true;
return compare(root->left, root->right);
}
};
代码每一步的逻辑非常清晰,体会之后就不难理解官方题解给出的代码:
class Solution {
public:
bool check(TreeNode* p, TreeNode* q) { //定义两个指针来遍历二叉树
if (!p && !q) return true; //两个指针都为空
if (!p || !q) return false; //另外两种指针情况
return p->val == q->val && check(p->left, q->right) && check(p->right, q->left); //指针指向的值相等
}
bool isSymmetric(TreeNode* root) {
return check(root, root);
}
};
解法二:迭代法
通过队列来比较左右子树是否互相翻转
这里要注意的是二叉树的遍历不是前中后序的遍历,也不是层序遍历
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; //若左右节点为空,此时对称,跳过本次循环中余下尚未执行的语句,执行下一次循环
if (!leftnode || !rightnode || (leftnode->val != rightnode->val)) return false; //左右一个节点不为空,或者都不为空但数值不相同,返回false
que.push(leftnode->left); //左节点左孩子入队
que.push(rightnode->right); //右节点右孩子入队
que.push(leftnode->right); //左节点右孩子入队
que.push(rightnode->left); //右节点左孩子入队
}
return true;
}
};
题目2:100.相同的树
其实解法和101是一样得,甚至代码只需要稍加修改就能直接用
解法一:递归法
class Solution {
public:
bool compare(TreeNode* p, TreeNode* q) {
if (p == NULL && q != NULL) return false;
else if (p != NULL && q == NULL) return false;
else if (p == NULL && q == NULL) return true;
else if (p->val != q->val) return false;
else {
//下边可以简化为 return compare(left->left,right->left) && compare(left->right, right->right);
bool ouside = compare(p->left, q->left);
bool inside = compare(p->right, q->right);
bool issame = ouside && inside;
return issame;
}
}
bool isSameTree(TreeNode* p, TreeNode* q) {
return compare(p,q);
}
};
同样,简洁的代码也可以稍加修改:
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if (p == NULL && q == NULL) return true; //等同于 if (!p && !q) return true;
if (p == NULL || q == NULL) return false; //等同于 if (!p || !q) return false;
return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
解法二:迭代法
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if (p == NULL && q == NULL) return true;
if (p == NULL || q == NULL) return false;
queue<TreeNode*> que;
que.push(p);
que.push(q);
while (!que.empty()) {
TreeNode* pnode = que.front(); que.pop();
TreeNode* qnode = que.front(); que.pop();
if (!pnode && !qnode) continue;
if (!pnode || !qnode || (pnode->val != qnode->val)) return false;
que.push(pnode->left);
que.push(qnode->left);
que.push(pnode->right);
que.push(qnode->right);
}
return true;
}
};
题目3:572.另一颗树的子树
要判断subroot是不是root的子树,可以判断subroot是否和root的任意子树相等,不就又和100题差不多了。
解法:递归法
class Solution {
public:
bool compare(TreeNode* root, TreeNode* subroot) {
if (root == NULL && subroot != NULL) return false;
else if (root != NULL && subroot == NULL) return false;
else if (root == NULL || subroot == NULL) return true;
else if (root->val != subroot->val) return false;
else {
//下边可以简化为 return compare(left->left,right->left) && compare(left->right, right->right);
bool ouside = compare(root->left, subroot->left);
bool inside = compare(root->right,subroot->right);
bool issame = ouside && inside;
return issame;
}
}
bool isSubtree(TreeNode* root, TreeNode* subroot) {
if (subroot == NULL) return true; //如果检验子树为空则一定包含
if (root == NULL) return false; //如果root为空则一定不包含
return compare(root,subroot) || isSubtree(root->left, subroot) || isSubtree(root->right, subroot); //重点就在这一句,subroot要么等于root本身、要么等于左子树、或右子树
}
};
以上代码也可以进行简化:
class Solution {
public:
bool compare(TreeNode* root, TreeNode* subroot) { // 从根节点开始遍历,找子树是否相等
if (!root && !subroot) return true;
if ((!root && subroot) || (root && !subroot || (root->val != subroot->val))) return false;
return compare(root->left,subroot->left) && compare(root->right,subroot->right);
}
bool isSubtree(TreeNode* root, TreeNode* subroot) {
if (!root) return false; //root为空则一定不包含
return compare(root,subroot) || isSubtree(root->left,subroot) || isSubtree(root->right,subroot);
}
};
或者:
class Solution {
public:
bool compare(TreeNode* root, TreeNode* subroot) {
if (root == nullptr && subroot == nullptr) return true; //
if (root == nullptr || subroot == nullptr) return false;
return root->val == subroot->val && compare(root->left,subroot->left) && compare(root->right,subroot->right);
}
bool isSubtree(TreeNode* root, TreeNode* subroot) {
if (!root) return false;
return isSubtree(root->left,subroot) || compare(root,subroot) || compare(root->right,subroot);
}
};
题目4:104.二叉树的最大深度
这里牵扯到二叉树的深度和高度,可以对比题110。
根节点的高度就是二叉树的最大深度。
解法一:递归法
求二叉树的最大深度,可以看成二叉树的最长子树加一(根节点),那么先求左右子树的深度,然后取最大值
class Solution {
public:
int getdepth(TreeNode* root) {
if (root == NULL) return 0; //如果根节点为空则直接返回0
int leftdepth = getdepth(root->left); //左子树深度
int rightdepth = getdepth(root->right); //右子树深度
int depth = max(leftdepth, rightdepth) + 1; //二叉树深度
return depth;
}
int maxDepth(TreeNode* root) {
getdepth(root);
}
};
精简代码可得:
class Solution {
public:
int maxDepth(TreeNode* root) {
if (root == NULL) return 0;
return 1 + max(maxDepth(root->left), maxDepth(root->right));
}
};
解法二:迭代法
层序遍历一层一层的遍历二叉树,到遍历到最后一层,就是二叉树的深度。
class Solution {
public:
int maxDepth(TreeNode* root) {
if (root == NULL) return 0;
queue<TreeNode*> que;
que.push(root);
int depth = 0; //层数
while (!que.empty()) {
int size = que.size();
depth++;
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return depth;
}
};
题目5:559.N叉树的最大深度
思路和104是一样的,只需要稍微修改下遍历的方式就可以了
解法一:递归法
class Solution {
public:
int maxDepth(Node* root) {
if (root == NULL) return 0;
int depth = 0;
for (int i = 0; i < root->children.size(); i++) {
depth = max(depth, maxDepth(root->children[i]));
}
return 1 + depth;
}
};
解法二:迭代法
class Solution {
public:
int maxDepth(Node* root) {
if (root == NULL) return 0;
queue<Node*> que;
que.push(root);
int depth = 0; //层数
while (!que.empty()) {
int size = que.size();
depth++;
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
for (int i = 0; i < node->children.size(); i++) {
if (node->children[i]) que.push(node->children[i]);
}
}
}
return depth;
}
};
题目6:111.二叉树的最小深度
解法一:递归法
大致的思路和之前104是一样的,但是要注意一点,叶子节点是指没有子节点的节点,即左右节点都为空。
如果一个节点的左字节为空,右子节点不为空,那么肯定不是叶子节点,就要在它右子节点继续找叶子节点。
class Solution {
public:
int getdepth(TreeNode* node) {
if (node == NULL) return 0;
int leftdepth = getdepth(node->left);
int rightdepth = getdepth(node->right); //这里还要进行判断是否为最低点
if (node->left == NULL && node->right != NULL) return 1 + rightdepth; //左子树空右子树不空
if (node->left != NULL && node->right == NULL) return 1 + leftdepth; //左子树不空右子树空
return 1 + min(leftdepth, rightdepth);
}
int minDepth(TreeNode* root) {
return getdepth(root);
}
};
精简代码后:
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == NULL) return 0;
if (root->left == NULL && root->right != NULL) return 1 + minDepth(root->right); //左子树空右子树不空
if (root->left != NULL && root->right == NULL) return 1 + minDepth(root->left); //左子树不空右子树空
return 1 + min(minDepth(root->left), minDepth(root->right));
}
};
解法二:迭代法
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == NULL) return 0;
queue<TreeNode*> que;
que.push(root);
int depth = 0; //层数
while (!que.empty()) {
int size = que.size();
depth++;
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
if (node->left == NULL && node->right == NULL) return depth;
}
}
return depth;
}
};