代码随想录算法训练营第19天|LeetCode226.翻转二叉树、LeetCode101.对称二叉树

最新推荐文章于 2024-07-25 13:44:24 发布

One1sAll

最新推荐文章于 2024-07-25 13:44:24 发布

阅读量389

点赞数 7

文章标签：算法

本文链接：https://blog.csdn.net/weixin_63948917/article/details/136597505

版权

代码随想录算法训练营第19天|LeetCode226.翻转二叉树、LeetCode101.对称二叉树

1.LeetCode226.翻转二叉树

226. 翻转二叉树 - 力扣（LeetCode）

在这里插入图片描述

第一想法：也就是对于每一个节点，对换left和right指针。感觉还是用层次遍历？

正确的想法！！但是想到的是迭代法，没有想到递归法。。。递归法代码超级简洁

迭代法

代码

先对换左右节点还是先push进队列里的顺序不影响结果。
另外，交换节点可以直接使用swap()函数

/**
 * Definition for a binary tree node.
 * 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:
    TreeNode* invertTree(TreeNode* root) {
      	//法1 层序遍历的迭代法
        queue<TreeNode*> que;
        if(root == NULL)
            return NULL;
        que.push(root);
        while(!que.empty()){
            TreeNode* top = que.front();
            que.pop();
            //对换左右节点
            TreeNode* left = top->left;
            TreeNode* right = top->right;
            top->left = right;
            top->right = left;
            //把左右节点再push进去
            if(top->left)
                que.push(top->left);
            if(top->right)
                que.push(top->right);
        }
        return root;
    }
};

递归法

使用先序遍历的递归法代码十分十分简单。

/**
 * Definition for a binary tree node.
 * 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:
    TreeNode* invertTree(TreeNode* root) {
		//法2 先序遍历的递归法
        if(root==NULL)
            return NULL;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

2.LeetCode101.对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

代码随想录 (programmercarl.com)

请添加图片描述

第一想法：或许可以看这棵树“左右中”和“右左中”的遍历结果是不是一样的，是一样的话那就是轴对称了。但是这样好像有点麻烦。

我的想法是对的！！

思路：要比较的是两个树（这两个树是根节点的左右子树），通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

递归法

递归三部曲

确定递归函数的参数和返回值

2个参数，分别是左右节点。1个返回值，表示是否对称bool型。
确定终止条件
- 左右均为空，true
- 左空右非空，false
- 左非空右空，false
- 左右均非空，但val不等，false
确定单层递归的逻辑

左右均非空，且val相等的情况。（注意这个是单层递归的逻辑而不是终止条件！！）

比较左右节点的外侧子节点是否相同，再比较内侧子节点是否相同。都相同则true，否则false。

代码（能够体现三部曲ver）

/**
 * Definition for a binary tree node.
 * 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:
    bool compare(TreeNode* left, TreeNode* right){
      	//边界情况
        if(left == NULL && right == NULL)
            return true;
        else if(left == NULL && right != NULL)
            return false;
        else if(left != NULL && right == NULL)
            return false;
        else if(left != NULL && right != NULL && left->val != right->val)
            return false;
     	//单层递归逻辑
        bool l = compare(left->left, right->right);
        bool r = compare(left->right, right->left);
        return l&&r;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        return compare(root->left, root->right);
    }
};

代码（更简洁ver但无法体现三部曲）

其实差别不大。

/**
 * Definition for a binary tree node.
 * 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:
    bool compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right == NULL)
            return true;
        else if(left == NULL && right != NULL)
            return false;
        else if(left != NULL && right == NULL)
            return false;
        else if(left != NULL && right != NULL && left->val != right->val)
            return false;
        // bool l = compare(left->left, right->right);
        // bool r = compare(left->right, right->left);
        // return l&&r;
      	
      	//差别在这里
        return compare(left->left, right->right && compare(left->right, right->left))
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        return compare(root->left, root->right);
    }
};

迭代法

使用队列/栈，每次弹出/加入俩节点。

下面是使用队列的代码，实际上使用栈是一样的，只是pop和push的时候一点小区别。

/**
 * Definition for a binary tree node.
 * 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:
    bool isSymmetric(TreeNode* root) {

        //法2 迭代
        if(root == NULL)
            return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
          	//成对pop
            TreeNode* left = que.front();
            que.pop();
            TreeNode* right = que.front();
            que.pop();
            if(!left && !right)
                continue;
            if((!left&&right) || (left&&!right))
                return false;
            if(left->val != right->val)
                return false;
        	//成对push
            que.push(left->left);
            que.push(right->right);
            que.push(left->right);
            que.push(right->left);
        }
        return true;
    }
};