代码随想录算法训练营第十五天| 层序遍历 、 226.翻转二叉树 、 101. 对称二叉树

102. 二叉树的层序遍历

题目:

给你二叉树的根节点 root ,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。

示例 1:


输入:root = [3,9,20,null,null,15,7]
输出:[[3],[9,20],[15,7]]


示例 2:

输入:root = [1]
输出:[[1]]


示例 3:

输入:root = []
输出:[]

思路:

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。需要借用一个辅助数据结构即队列来实现,队列先进先出,符合一层一层遍历的逻辑,而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历,只不过我们应用在二叉树上。

代码:

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size = que.size(); // 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
            vector<int> vec;
            for(int i = 0; i < size; i++){
                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. 翻转二叉树

题目:

给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。

示例 1:

输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]


示例 2:

输入:root = [2,1,3]
输出:[2,3,1]


示例 3:

输入:root = []
输出:[]

思路:

可以发现想要翻转它,其实就把每一个节点的左右孩子交换一下就可以了。

针对二叉树的问题,解题之前一定要想清楚究竟是前中后序遍历,还是层序遍历。

这道题目使用前序遍历和后序遍历都可以,唯独中序遍历不方便,因为中序遍历会把某些节点的左右孩子翻转了两次!建议拿纸画一画,就理解了

那么层序遍历可以不可以呢?依然可以的!

代码:

递归法:

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL) return root;
        swap(root->left, root->right); // 中,前序遍历
        invertTree(root->left);        // 左
        invertTree(root->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); // 右
                if(node->left) st.push(node->left);   // 左
                st.push(node);                        // 中
                st.push(NULL);
            }
            else{
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left, node->right);         // 节点处理逻辑
            }
        }
        return root;

    }
};

迭代法:(广度优先遍历,层序遍历)

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->right) que.push(node->right);
                if(node->left) que.push(node->left); 
            }           
        }
        return root;
    }
};

101. 对称二叉树

题目:

给你一个二叉树的根节点 root , 检查它是否轴对称。

示例 1:


输入:root = [1,2,2,3,4,4,3]
输出:true


示例 2:


输入:root = [1,2,2,null,3,null,3]
输出:false

思路:

递归三部曲

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

因为我们要比较的是根节点的两个子树是否是相互翻转的,进而判断这个树是不是对称树,所以要比较的是两个树,参数自然也是左子树节点和右子树节点。返回值自然是bool类型。

2. 确定终止条件

要比较两个节点数值相不相同,首先要把两个节点为空的情况弄清楚!否则后面比较数值的时候就会操作空指针了。

节点为空的情况有:(注意我们比较的其实不是左孩子和右孩子,所以如下我称之为左节点右节点

  • 左节点为空,右节点不为空,不对称,return false
  • 左不为空,右为空,不对称 return false
  • 左右都为空,对称,返回true

此时已经排除掉了节点为空的情况,那么剩下的就是左右节点不为空:

  • 左右都不为空,比较节点数值,不相同就return false

此时左右节点不为空,且数值也不相同的情况我们也处理了。

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{
            // 此时就是:左右节点都不为空,且数值相同的情况
            // 此时才做递归,做下一层的判断
            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;
        bool r = compare(root->left, root->right);
        return r;
    }
};

迭代法

我们可以使用队列来比较两个树(根节点的左右子树)是否相互翻转,(注意这不是层序遍历

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* leftN = que.front(); que.pop();
            TreeNode* rightN = que.front(); que.pop();
            if(!leftN && !rightN) continue; // 左节点为空、右节点为空,此时说明是对称的
            if(!leftN || !rightN || (leftN->val != rightN->val)){
                return false; // 左右一个节点不为空,或者都不为空但数值不相同,返回false
            }
            que.push(leftN->left); que.push(rightN->right); //加入左节点的左孩子,右节点的右孩子
            que.push(leftN->right); que.push(rightN->left); //加入左节点的右孩子,右节点的左孩子

        }
        return true;
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值