代码随想录day13 lc102, 107, 199, 637, 429, 515, 116, 117, 104, 111, 226, 101

102. Binary Tree Level Order Traversal
     https://leetcode.cn/problems/binary-tree-level-order-traversal/

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>>res;
        if (!root) {
            return res;
        }
        queue<TreeNode*>q;
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            vector<int>level;
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                level.push_back(curr->val);
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
            res.push_back(level);
        }
        return res;
    }
};

103. Binary Tree Level Order Traversal II
     从下往上返回每层的值
     反转result数组

104. Populating Next Right Pointers in Each Node
     https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/
     每次把prev->next设为curr，再resassign curr

105. Binary Tree Level Order Traversal
     https://leetcode.cn/problems/binary-tree-level-order-traversal/
     只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

class Solution {
public:
    int minD = INT_MAX;
    void dfs(TreeNode* root, int d) {
        if (!root) {
            return;
        }
        if (!root->left && !root->right) {
            minD = min(minD, d);
            return;
        }
        
        dfs(root->left, d + 1);
        dfs(root->right, d + 1);
    }
    int minDepth(TreeNode* root) {
        dfs(root, 0);
        return minD == INT_MAX ? 0: minD + 1;
    }
};

106. Invert Binary Tree
     https://leetcode.cn/problems/invert-binary-tree/

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (!root) {
            return root;
        }
        swap(root->left, root->right);
        invertTree(root->right);
        invertTree(root->left);
        return root;
    }
};

中序遍历：有些node会被交换两次（DFS）
用迭代的方式的中序不会交换两次

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
        return root;
    }
};

从时间复杂度上其实迭代法和递归法差不多（在不考虑函数调用开销和函数调用产生的堆栈开销），但是空间复杂度上，递归开销会大一些，因为递归需要系统堆栈存参数返回值等等。

101. Symmetric Tree
     https://leetcode.cn/problems/symmetric-tree/
     判断对称二叉树要比较的是哪两个节点，要比较的不是左右节点

class Solution {
public:
    bool isSymmetricHelper(TreeNode* l, TreeNode* r) {
        if (!l && !r) {
            return true;
        } else if (!l || !r) {
            return false;
        } else if (l->val != r->val) {
            return false;
        }
        // 后序遍历/backtrack，左右中
        return isSymmetricHelper(l->left, r->right) && isSymmetricHelper(l->right, r->left);
    }
    bool isSymmetric(TreeNode* root) {
        if  (!root) {
            return true;
        }
        return isSymmetricHelper(root->left, root->right);
    }
};

用栈/队列遍历比较（顺序相同）

st.push(leftNode->left);
st.push(rightNode->right);
st.push(leftNode->right);
st.push(rightNode->left);