程式碼隨想錄演算法訓練營第十四天| 226.翻轉二叉樹 、101. 對稱二叉樹、104.二叉樹的最大深度 （優先掌握遞迴）、111.二叉樹的最小深度

二叉樹學習2

226題翻轉二叉樹，改一下前序遞迴遍歷，每次遍歷的時候都調換一下左右結點即可。

class Solution {
public:
void preorder(TreeNode *root) {
        if (root == nullptr) {
            return;
        }
        TreeNode* tmp;
        tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        preorder(root->left);
        preorder(root->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        preorder(root);
        return root;
    }
};

101判定是不是對稱二叉樹，我的做法太麻煩了，對兩棵樹分別遍歷(中左右 中右左)，再比較值是否相同，其實可以放在一個函式里一次性解決。

class Solution {
public:
    void preorder1(TreeNode *root, vector<int> &res) {
        if (root == nullptr) {
            res.push_back(-101);
            return;
        }
        res.push_back(root->val);
        preorder1(root->left, res);
        preorder1(root->right, res);
    }
    void preorder2(TreeNode *root, vector<int> &res) {
        if (root == nullptr) {
            res.push_back(-101);
            return;
        }
        res.push_back(root->val);
        preorder2(root->right, res);
        preorder2(root->left, res);

    }
    bool isSymmetric(TreeNode* root) {
        
        vector<int> res;
        vector<int> ans;
       
        preorder1(root->left, res);
        preorder2(root->right, ans);
        
        // 比較兩個陣列
        for (int i = 0; i < res.size(); i++) {
            if (res[i] != ans[i])  
                return false;
        }
        return true;
    }
};

104題二叉樹的最大深度 111題二叉樹的最小深度在上一節完成了

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 這裡一定要使用固定大小size，不要使用que.size()，因為que.size是不斷變化的
            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);
            depth++;
        }
        return depth;
    }
};

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (!root) {
            return 0;
        }
        queue<TreeNode*> que;
        que.push(root);
        
        int depth = 0;

        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 這裡一定要使用固定大小size，不要使用que.size()，因為que.size是不斷變化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (!node->left && !node->right) {
                    return ++depth;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};