day-15 代码随想录算法训练营（19） 二叉树part02（层序遍历、递归）

226.翻转二叉树

思路一：使用队列层序遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        //思路：层序遍历，判断每一个节点是否有左右节点，分三种情况
        queueque;
        if(root==nullptr)
            return root;
        que.push(root);//加入根节点
        while(!que.empty())
        {
            int len=que.size();
            cout<val<<"\t";
                
                if(cur->left!=nullptr  && cur->right!=nullptr)//分三种情况讨论
                {
                    TreeNode*temp=cur->left;
                    cur->left=cur->right;
                    cur->right=temp;
                    que.push(cur->left);
                    que.push(cur->right);
                }
                else if(cur->left!=nullptr && cur->right==nullptr)
                {
                    cur->right=cur->left;
                    cur->left=nullptr;
                    que.push(cur->right);
                }
                else if(cur->right!=nullptr && cur->left==nullptr)
                {
                    cur->left=cur->right;
                    cur->right=nullptr;
                    que.push(cur->left);
                }
                // else 
                //     cout<<1<

问题：刚开始没判断root是否为为空，调试打印数据看着很乱，还以为哪出问题了

总结：极端条件一开始就需要考虑！！！

思路二：递归，直接使用swap函数交换左右节点在父节点那的位置

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

101.对称二叉树

思路一：没想到还能这么遍历，直接比较两颗二叉树

class Solution {
public:
    bool compare(TreeNode*left,TreeNode*right)
    {
        //首先排除节点为空的情况
        if(left==nullptr && right==nullptr) return true;
        else if(left!=nullptr && right==nullptr) return false;
        else if(left==nullptr && right!=nullptr) return false;
        //下面左右节点都存在
        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==nullptr) return true;
        return compare(root->left,root->right);
    }
};

思路二：先翻转左二叉树，然后跟右二叉树作比较

越搞越复杂，放弃

114.二叉树展开为链表

思路一：先前序遍历存入数组，在依次改变节点的连接

class Solution {
public:
    void judge(TreeNode*root,vector&nodes)
    {
        if(root==nullptr)
            return;
        nodes.push_back(root);
        judge(root->left,nodes);
        judge(root->right,nodes);
    }
    void flatten(TreeNode* root) {
        //思路一：先序遍历，节点加入容器，然后连接
        //思路二：递归直接改变指针
        vectornodes;
        if(root==nullptr)
            return;
        judge(root,nodes);
        //cout<right=node;
            node->left=nullptr;
            pre=node;
        }
    }
};

104.二叉树的最大深度

思路：层序遍历

class Solution {
public:
    int maxDepth(TreeNode* root) {
        //层序遍历
        if(root==nullptr)
            return 0;
        queueque;
        que.push(root);
        int deep=0;
        while(!que.empty())
        {
            int len=que.size();
            for(int i=0;ileft)
                    que.push(cur->left);
                if(cur->right)
                    que.push(cur->right);
            }
            deep++;
        }
        return deep;

    }
};