代码随想录打卡—day15—【二叉树】— 层序遍历 8.4-8.5

Vaidurya_99

已于 2023-08-05 10:40:13 修改

阅读量62

点赞数

分类专栏： SXL 文章标签：数据结构算法

于 2023-08-04 16:16:27 首次发布

本文链接：https://blog.csdn.net/weixin_60899084/article/details/132101594

版权

SXL 专栏收录该内容

42 篇文章 1 订阅

订阅专栏

1 层序遍历

层序遍历思路：

先搞一个空队列，把根放进去，循环——队列非空时候，设当前队列长度 size，遍历当前层（即size次），每次就把队首取出来，然后存入左右儿子，再循环直到队列空。其实每一次循环都是遍历一层的过程。

102. 二叉树的层序遍历

AC代码：

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        queue<TreeNode*> q;
        vector<int> tmp;
        if(root != nullptr)
        {
            q.push(root);
        }
        else return ans;

        while(!q.empty())
        {
            int size = q.size();;
            tmp.clear();
            for(int i = 0; i <size; i++)
            {
                TreeNode* front = q.front();
                tmp.push_back(front->val);
                q.pop();
                if(front->left != nullptr)q.push(front->left);
                if(front->right != nullptr)q.push(front->right);
            }
            ans.push_back(tmp);
        }
        return ans;
    }
};

2 层序遍历的相关题目

107. 二叉树的层序遍历 II

和102二叉树的层序遍历一样，最后vector 翻转一下就行，

reverse(ans.begin(),ans.end());

116. 填充每个节点的下一个右侧节点指针

117. 填充每个节点的下一个右侧节点指针 II

（117和116代码一模一样)

104. 二叉树的最大深度

111. 二叉树的最小深度

这几题很简单，就在102二叉树的层序遍历改就行了，全都过了，AC代码不放了。

3 题1——翻转二叉树

思路：只要把每一个节点的左右孩子翻转一下。

" 使用前序遍历，后序遍历，层序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了 " 但我不太理解。

我的层序遍历AC 写法：

/**
 * 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) {
        // 还是层序遍历
        queue<TreeNode*> q;
        if(root != nullptr)
        {
            q.push(root);
        }
        else return root;

        while(!q.empty())
        {
            int size = q.size();
            for(int i = 0; i <size; i++)
            {
                TreeNode* front = q.front();
                q.pop();
                swap(front->left,front->right);

                if(front->left != nullptr)q.push(front->left);
                if(front->right != nullptr)q.push(front->right);
            }
        }
        return root;
    }
};

4 题2——对称二叉树

一开始一个思路：右子树翻转一下，然后直接root->left == root->right 判断左右子树是否相等，大错特错！因为左右子树根节点存储的就三个变量，要遍历才能看出相等不相等。

换一个思路：左边子树（左中右搜索）假设递归到左边最下角，但怎么和右边子树递归的（右中左搜索）假设低轨道右边最下角对比。不会写这种同时两个递归的，学习carl思路。

carl 思路，这里还有用迭代队列，栈的其他写法

AC代码：

/**
 * 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* root1,TreeNode* root2)
    {
        if(root1== nullptr && root2 == nullptr)return 1;
        else if (root1 == nullptr || root2 ==nullptr)return 0;
        else if(root1->val != root2->val)return 0;  // 中

        // 到这一步的都是对应位置val相等的就可以进一步递归了
        bool ans1 = compare(root1->left,root2->right);  
        bool ans2 = compare(root1->right,root2->left);  
        if(ans1 & ans2)return 1;
        else return 0;
    }


    bool isSymmetric(TreeNode* root) 
    {
       // 左子树： 中左右 ，右子树：中右左
       if(root->left==nullptr && root->right==nullptr)return 1;
       else if(root->left && root->right )
       return compare(root->left,root->right);
       else return 0;
    }
};

4.1 题2类似的题（题型：同时遍历两个树）

100. 相同的树

比较简单，ac了代码略。

572. 另一棵树的子树

思路：首先深度遍历root 每一个节点作为新树节点与subRoot进行比较。。AC代码：

/**
 * 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* root1,TreeNode* root2)
    {
        if(root1== nullptr && root2 == nullptr)return 1;
        else if (root1 == nullptr || root2 ==nullptr)return 0;
        else if(root1->val != root2->val)return 0;  // 中

        // 到这一步的都是对应位置val相等的就可以进一步递归了
        bool ans1 = compare(root1->left,root2->left);  
        bool ans2 = compare(root1->right,root2->right);  
        if(ans1 & ans2)return 1;
        else return 0;
    }
    bool haha(TreeNode* root,TreeNode* subRoot)
    {
        if(root == nullptr)return 0;

        bool ans1 = haha(root->left,subRoot);
        bool ans3 = compare(root,subRoot);
        bool ans2 = haha(root->right,subRoot);
        if(ans1 || ans2 || ans3)return 1;
        else return 0;
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) 
    {
        //  首先深度遍历root 每一个节点作为新树节点与subRoot进行比较
        return haha(root, subRoot);
    }
};