day15：层序遍历 10226.翻转二叉树101.对称二叉树 2

今日内容：

• 层序遍历 10

• 226.翻转二叉树

• 101.对称二叉树 2

详细布置

层序遍历

class Solution {

public:

    vector<vector<int>> levelOrder(TreeNode* root) {

        vector<vector<int>> result;

        queue<TreeNode*> que;

        if (root != nullptr) que.push(root);

        while(!que.empty()){

            int 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.翻转二叉树 （优先掌握递归）

递归三部曲

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

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

跟着视频讲解手写了一遍，学习了其递归的思路

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 result = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return result;

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};