代码随想录刷题第15天|二叉树 LeetCode102层序遍历、LeetCode226翻转二叉树、LeetCode101对称二叉树

1、LeetCode102 层序遍历

题目链接：102、层序遍历

构建一个队列存储节点，每次从队头弹出元素。

将根节点放入队列，当队列不为空时，弹出队头元素，同时处理该元素的左右孩子，左右孩子不为空则将左右孩子放入队中，记录队列中的元素个数，有几个元素弹出几次。

注意：队列的头 que.front()

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if ( root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while(size--)
            {
                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;
    }
};

递归写法：

递归的条件写不出来，if (result.size() == depth) result.push_back(vector<int>()) 

result[depth].push_back(cur->val)

class Solution {
public:
    void order(TreeNode * cur, vector<vector<int>>& result, int depth)
    {
        if (cur == NULL) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

10个相关题目：

102.二叉树的层序遍历；107.二叉树的层次遍历II；199.二叉树的右视图

637.二叉树的层平均值；429.N叉树的层序遍历；515.在每个树行中找最大值

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

104.二叉树的最大深度；111.二叉树的最小深度

2、LeetCode226 翻转二叉树

题目链接：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) {
        stack<TreeNode*> st;
        if (root != NULL) 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();
            while(size--)
            {
                TreeNode * Node = que.front();
                que.pop();
                swap(Node->left, Node->right);
                if (Node->left) que.push(Node->left);
                if (Node->right) que.push(Node->right);
            }
        }
        return root;
    }
};

3、LeetCode101 对称二叉树

题目链接：101、对称二叉树

文章链接：代码随想录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);

    }
};

使用队列的迭代法

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 == NULL && rightNode == NULL) 
            {  
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((leftNode == NULL || rightNode == NULL || leftNode->val != rightNode->val))            
            {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};