12.二叉树Ⅱ

最新推荐文章于 2024-07-19 19:25:43 发布

ziyu2020

最新推荐文章于 2024-07-19 19:25:43 发布

阅读量1.3k

点赞数

分类专栏： leetcode刷题文章标签：深度优先 leetcode 算法

本文链接：https://blog.csdn.net/ziyu2020/article/details/128189248

版权

leetcode刷题专栏收录该内容

19 篇文章 0 订阅

订阅专栏

12.二叉树Ⅱ

102.二叉树的层序遍历

题目描述

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

示例 1：

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

解题思路

队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E1k3XzIT-1670229498849)(https://tva1.sinaimg.cn/large/008eGmZEly1gnad5itmk8g30iw0cqe83.gif)]

步骤：根节点入队，根节点出队，节点出队时其子节点入队。

代码实现

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>res;//vector容器存结果
        queue<TreeNode*>que;//队列中放的不是int，而是treeNode的指针，指向二叉树节点的指针
        TreeNode*cur;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size=que.size();//代表了每一层节点的个数
            vector<int>tmp;//存储层元素，每一层都需要重新初始化，否则各层元素会堆叠
            for(int i=0;i<size;i++)//对当前层每个节点都执行出队，子节点入队的操作
            {
                cur=que.front();//将队头元素作为当前节点
                que.pop();//出队头
                tmp.push_back(cur->val);//队头元素入层结果
                if(cur->left) que.push(cur->left);//当前节点有子节点的话子节点入队
                if(cur->right)  que.push(cur->right);
            }
            res.push_back(tmp);
        }
        return res;
    }
};

总结

利用一个while，一个for实现对二叉树的层遍历。

while里面判断条件是队列是否为空。for循环次数为队列长度。在每个循环内将本层的节点记录到层数组tmp中，同时令下一层的节点都入队列。这样下次再执行层遍历的时候，只需要根据队列的size就可以决定for循环的次数。直到达到最后一层节点，起下一层子节点均为空，自然for循环内出队完队列也变为空，跳出while循环，完成层遍历。

需要注意，层结果的vector需要定义在while内，每个迭代过程重新初始化，保证只存储当前层的元素。

226.翻转二叉树

题目描述

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

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CBuXHO1x-1670229498849)(https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)]

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

解题思路

在遍历二叉树的基础上，增加节点左右指针交换操作。

代码实现

递归法，调用自己。交换顺序，中左右，按三部曲写递归程序。

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:
//迭代法，深度优先遍历，利用栈的数据结构，前序遍历
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        stack<TreeNode*>st;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* node=st.top();
            st.pop();
            swap(node->left,node->right);
            if(node->right) st.push(node->right);//右，先进，后出。
            if(node->left) st.push(node->left);//左，后进先出
        }
    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*cur=que.front();
                que.pop();
                swap(cur->left,cur->right);
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
        }
        return root;
    }
};

总结

二叉树翻转并不是去改节点的数据，而是交换左右指针的指向。

反转与遍历相似，只不过在遍历每一个节点后增加一个额外的左右指针指向交换。

方法有三种：递归法。按照三部曲写，写递归函数输入输出，跳出条件，单层递归逻辑。

深度优先（栈的数据结构），根节点入栈，栈顶出栈，交换栈顶元素左右指针，栈顶左右孩子入栈。while循环跳出条件，栈为空。

广度优先（队列的数据结构）：根节点入队。只要队列不为空，记录队列长度，for遍历队列，在每个循环，队头出队，交换队头元素左右节点，同时令队头元素的左右孩子入队。while跳出条件是队列元素为空。

101. 对称二叉树（优先掌握递归）

1.题目描述

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

2.解题思路

对一个子树按照左右中遍历，另一个子树按照右左中遍历。

方法1，递归

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

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

返回值自然是bool类型。

代码如下：

bool compare(TreeNode* left, TreeNode* right)

2.确定终止条件

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

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

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

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

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

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

3.确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

方法2，队列

101.对称二叉树

3.代码实现

递归代码

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;
    }
};

4.总结

对于二叉树的遍历，翻转，对称判断，通常有两种方法，一种递归法，一种迭代法。

t); // 加入左节点左孩子
que.push(rightNode->right); // 加入右节点右孩子
que.push(leftNode->right); // 加入左节点右孩子
que.push(rightNode->left); // 加入右节点左孩子
}
return true;
}
};




### 4.总结

对于二叉树的遍历，翻转，对称判断，通常有两种方法，一种递归法，一种迭代法。

迭代法利用栈或队列的数据结构，巧妙地根据需要令节点入队、出队、判断。

ziyu2020

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
12.二叉树Ⅱ

给你二叉树的根节点，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。解题思路队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
复制链接

扫一扫