Follow Carl To Grow|【LeetCode】102.层序遍历，226.翻转二叉树，101.对称二叉树

【LeetCode】102.层序遍历

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

思路：递归记录深度。迭代用队列，注意每一层遍历时先固定长度。

代码A：

/**
 * 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:
    void level(TreeNode* root, vector<vector<int>> &order, int depth)
    {
        if (!root)
        {
            return;
        }
        // 为了能下标访问
        if (order.size() == depth)
        {
            order.push_back(vector<int>());
        }
        order[depth].push_back(root->val);
        level(root->left, order, depth + 1);
        level(root->right, order, depth + 1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        level(root, res, 0);
        return res;
    }
};

代码B：

/**
 * 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) {
        queue<TreeNode*> q;
        vector<vector<int>> res;
        if (!root)
        {
            return res;
        }
        q.push(root);
        while (!q.empty())
        {
            int size = q.size();
            vector<int> level;
            for (int i = 0; i < size; ++i)
            {
                TreeNode* node = q.front();
                q.pop();
                level.push_back(node->val);
                if (node->left)
                {
                    q.push(node->left);
                }
                if (node->right)
                {
                    q.push(node->right);
                }
            }
            res.push_back(level);
        }
        return res;
    }
};

---

【LeetCode】226.翻转二叉树

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

思路：利用先序遍历，递归和统一迭代都可以。

代码A：

/**
 * 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) {
        if (!root)
        {
            return root;
        }
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

代码B：

/**
 * 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) {
        stack<TreeNode*> stk;
        if (!root)
        {
            return root;
        }
        stk.push(root);
        while (!stk.empty())
        {
            TreeNode* node = stk.top();
            if (node)
            {
                stk.pop();
                if (node->right)
                {
                    stk.push(node->right);
                }
                if (node->left)
                {
                    stk.push(node->left);
                }
                stk.push(node);
                stk.push(NULL);
            }
            else
            {
                stk.pop();
                node = stk.top();
                stk.pop();
                swap(node->left, node->right);
            }
        }
        return root;
    }
};

---

【LeetCode】101.对称二叉树

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

思路：递归判断左右两颗子树是否相同，实际上是左边的右子树和右边的左子树、左边的左子树和右边的右子树是否相同。

代码：

/**
 * 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* left, TreeNode* right)
    {
        // 先处理有空结点的情况
        if (!left && right)
        {
            return false;
        }
        else if (left && !right)
        {
            return false;
        }
        else if (!left && !right)
        {
            return true;
        }
        else
        {
            // 判断结点值
            if (left->val != right->val)
            {
                return false;
            }
            else
            {
                bool bright = compare(left->right, right->left);
                bool bleft = compare(left->left, right->right);
                return bright && bleft;
            }
        }
    }

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

---

心态：“第六章 二叉树 part02” 拿下！
参考资料