二叉树

144. 二叉树的前序遍历

给你二叉树的根节点 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:
    void preorder(vector<int>& result, const TreeNode* current) {
        if (current == nullptr) {
            return;
        }
        result.push_back(current->val);
        preorder(result, current->left);
        preorder(result, current->right);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        preorder(result, root);
        return result;
    }
};

二叉树前序遍历的迭代法

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode *> st;
        vector<int> result;
        if (root == nullptr) {
            return result;
        }
        st.push(root);
        while (!st.empty()) {
            TreeNode *node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->right != nullptr) {
                st.push(node->right);
            }
            if (node->left != nullptr) {
                st.push(node->left);
            }
        }
        return result;
    }
};

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。

class Solution {
public:
    void inorder(vector<int>& result, const TreeNode* current) {
        if (current == nullptr) {
            return;
        }
        inorder(result, current->left);
        result.push_back(current->val);
        inorder(result, current->right);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        inorder(result, root);
        return result;
    }
};

二叉树中序遍历的迭代法

比较复杂，相当复杂。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode *> st;
        TreeNode *cur = root;
        while (cur != nullptr || !st.empty()) {
            if (cur != nullptr) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

145. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

class Solution {
public:
    void postorder(vector<int>& result, const TreeNode* current) {
        if (current == nullptr) {
            return;
        }
        postorder(result, current->left);
        postorder(result, current->right);
        result.push_back(current->val);
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        postorder(result, root);
        return result;
    }
};

二叉树后序遍历的迭代法

先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转 result 数组，输出的结果顺序就是左右中了

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode *> st;
        vector<int> result;
        if (root == nullptr) {
            return result;
        }
        st.push(root);
        while (!st.empty()) {
            TreeNode *node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left != nullptr) {
                st.push(node->left);
            }
            if (node->right != nullptr) {
                st.push(node->right);
            }
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

二叉树的统一迭代法

前序：右 → 左 → 中
中序：右 → 中 → 左
后序：中 → 右 → 左

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode *> st;
        if (root != nullptr) {
            st.push(root);
        }
        while (!st.empty()) {
            TreeNode *node = st.top();
            if (node != nullptr) {
                st.pop();
                st.push(node);
                st.push(nullptr);
                if (node->right != nullptr) {
                    st.push(node->right);
                }
                if (node->left != nullptr) {
                    st.push(node->left);
                }
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

102. 二叉树的层序遍历

力扣题目链接(opens new window)

给你一个二叉树，请你返回其按层序遍历得到的节点值。

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

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

力扣题目链接

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node *> que;
        if (root == nullptr) {
            return root;
        }
        que.push(root);

        while(!que.empty()) {
            int size = que.size();
            Node *last = nullptr;
            for (int i = 0; i < size; i++) {
                auto node = que.front();
                que.pop();
                if (last) {
                    last->next = node;
                }
                last = node;
                if (node->left) {
                    que.push(node->left);
                }
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};

226. 翻转二叉树

力扣题目链接(opens new window)

翻转一棵二叉树。

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

101. 对称二叉树

力扣题目链接(opens new window)

给定一个二叉树，检查它是否是镜像对称的。

class Solution {
public:
    bool compareSymmetric(TreeNode* left, TreeNode*right) {
        if (!left && !right) {
            return true;
        } else if (!left || !right) {
            return false;
        }
        return left->val == right->val && compareSymmetric(left->left, right->right) && compareSymmetric(left->right, right->left);
    }

    bool isSymmetric(TreeNode* root) {
        if (!root) {
            return false;
        }
        return compareSymmetric(root->left, root->right);
    }
};

还不太会迭代法怎么解决。

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

class Solution {
public:
    int getDepth(TreeNode *node) {
        if (!node) {
            return 0;
        }
        return max(getDepth(node->left), getDepth(node->right)) + 1;
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

222. 完全二叉树的节点个数

力扣题目链接(opens new window)

给出一个完全二叉树，求出该树的节点个数。

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (!root) {
            return 0;
        }
        TreeNode* left = root->left;
        int leftDepth = 0;
        while (left) {
            left = left->left;
            leftDepth++;
        }
        TreeNode* right = root->right;
        int rightDepth = 0;
        while (right) {
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1;
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

时间复杂度： $O(\log^2{n})$
官方题解空间复杂度为 $O(1)$ ，这里是 $O(\log{n})$

110. 平衡二叉树

力扣题目链接(opens new window)

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

class Solution {
public:
    int checkBalanced(TreeNode* root, bool &isBalanced) {
        if (!isBalanced) {
            return 0;
        }
        if (!root) {
            return 0;
        }
        int leftDepth = checkBalanced(root->left, isBalanced);
        int rightDepth = checkBalanced(root->right, isBalanced);
        if (isBalanced && (abs(leftDepth - rightDepth) > 1)) {
            isBalanced = false;
        }
        return max(leftDepth, rightDepth) + 1;
    }

    bool isBalanced(TreeNode* root) {
        bool isBalanced = true;
        checkBalanced(root, isBalanced);
        return isBalanced;
    }
};

还可以用 -1 表示不平衡，不需要额外传入引用了。

257. 二叉树的所有路径

力扣题目链接(opens new window)

给定一个二叉树，返回所有从根节点到叶子节点的路径。

class Solution {
public:
    void printPaths(TreeNode* root, vector<int>& tmp, vector<string>& ans) {
        tmp.push_back(root->val);
        if (root->left) {
            printPaths(root->left, tmp, ans);
        }
        if (root->right) {
            printPaths(root->right, tmp, ans);
        }
        if (!root->left && !root->right && !tmp.empty()) {
            string res = to_string(tmp[0]);
            for (int i = 1; i < tmp.size(); i++) {
                res = res + "->" + to_string(tmp[i]);
            }
            ans.push_back(res);
        }
        tmp.pop_back();
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> ans{};
        if (!root) {
            return ans;
        }
        vector<int> tmp;
        printPaths(root, tmp, ans);
        return ans;
    }
};

404. 左叶子之和

力扣题目链接(opens new window)

计算给定二叉树的所有左叶子之和。

class Solution {
public:
    void sumLeft(TreeNode* root, int& res) {
        if (!root) {
            return;
        }
        if (root->left && !root->left->left && !root->left->right) {
            res += root->left->val;
        } else {
            sumLeft(root->left, res);
        }
        sumLeft(root->right, res);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int res = 0;
        sumLeft(root, res);
        return res;
    }
};

513. 找树左下角的值

力扣题目链接(opens new window)

给定一个二叉树，在树的最后一行找到最左边的值。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode *> vec;
        if (root) {
            vec.push(root);
        }
        int leftVal;
        while (!vec.empty()) {
            int size = vec.size();
            for (int i = 0; i < size; i++) {
                TreeNode *node = vec.front();
                vec.pop();
                if (node->left) {
                    vec.push(node->left);
                }
                if (node->right) {
                    vec.push(node->right);
                }
                if (i == 0) {
                    leftVal = node->val;
                }
            }
        }
        return leftVal;
    }
};

112. 路径总和

力扣题目链接(opens new window)

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        stack<pair<TreeNode*, int>> stk;
        if (root) {
            stk.push({root, root->val});
        }
        while (!stk.empty()) {
            auto currPair = stk.top();
            stk.pop();
            if (!currPair.first->left && !currPair.first->right && targetSum == currPair.second) {
                return true;
            }
            if (currPair.first->right) {
                stk.push({currPair.first->right, currPair.second + currPair.first->right->val});
            }
            if (currPair.first->left) {
                stk.push({currPair.first->left, currPair.second + currPair.first->left->val});
            }
        }
        return false;
    }
};

113. 路径总和 ii

力扣题目链接(opens new window)

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

==这次使用了递归==

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void dfs(TreeNode* curr, int targetSum) {
        path.push_back(curr->val);
        if (!curr->left && !curr->right && curr->val == targetSum) {
            res.push_back(path);
        }
        if (curr->left) {
            dfs(curr->left, targetSum - curr->val);
        }
        if (curr->right) {
            dfs(curr->right, targetSum - curr->val);
        }
        path.pop_back();
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        res.clear();
        path.clear();
        if (root) {
            dfs(root, targetSum);
        }
        return res;
    }
};

106. 从中序与后序遍历序列构造二叉树

力扣题目链接(opens new window)

根据一棵树的中序遍历与后序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder, int inBegin, int inEnd, int postBegin, int postEnd) {
        if (inorder.size() == 0 || inBegin == inEnd) {
            return nullptr;
        }
        if (inEnd - inBegin == 1) {
            return new TreeNode(inorder[inBegin]);
        }
        int rootVal = postorder[postEnd - 1];
        int rootIndex = -1;
        for (int i = inBegin; i < inEnd; i++) {
            if (inorder[i] == rootVal) {
                rootIndex = i;
                break;
            }
        }
        return new TreeNode(rootVal, traversal(inorder, postorder, inBegin, rootIndex, postBegin, postBegin + rootIndex - inBegin), traversal(inorder, postorder, rootIndex + 1, inEnd, postBegin + rootIndex - inBegin, postEnd - 1));
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder, 0, inorder.size(), 0, postorder.size());
    }
};

105. 从前序与中序遍历序列构造二叉树

力扣题目链接(opens new window)

根据一棵树的前序遍历与中序遍历构造二叉树。

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder, int pBegin, int pEnd, int iBegin, int iEnd) {
        if (inorder.size() == 0 || iBegin == iEnd) {
            return nullptr;
        }
        if (iEnd - iBegin == 1) {
            return new TreeNode(inorder[iBegin]);
        }
        int rootVal = preorder[pBegin];
        int rootIndex = -1;
        for (int i = iBegin; i < iEnd; i++) {
            if (inorder[i] == rootVal) {
                rootIndex = i;
                break;
            }
        }
        return new TreeNode(rootVal, traversal(preorder, inorder, pBegin + 1, pBegin + 1 + rootIndex - iBegin, iBegin, rootIndex), traversal(preorder, inorder, pBegin + 1 + rootIndex - iBegin, pEnd, rootIndex + 1, iEnd));
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return traversal(preorder, inorder, 0, preorder.size(), 0, inorder.size());
    }
};

654. 最大二叉树

力扣题目地址(opens new window)

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

二叉树的根是数组中的最大元素。
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。

通过给定的数组构建最大二叉树，并且输出这个树的根节点。

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int begin, int end) {
        if (end == begin) {
            return nullptr;
        }
        if (end - begin == 1) {
            return new TreeNode(nums[begin]);
        }
        int maxVal = nums[begin];
        int maxIndex = begin;
        for (int i = begin + 1; i < end; i++) {
            if (maxVal < nums[i]) {
                maxVal = nums[i];
                maxIndex = i;
            }
        }
        return new TreeNode(maxVal, traversal(nums, begin, maxIndex), traversal(nums, maxIndex + 1, end));
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if (nums.empty()) {
            return nullptr;
        }
        return traversal(nums, 0, nums.size());
    }
};

617. 合并二叉树

力扣题目链接(opens new window)

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 != nullptr && root2 != nullptr) {
            return new TreeNode(root1->val + root2->val, mergeTrees(root1->left, root2->left), mergeTrees(root1->right, root2->right));
        } else if (root1 != nullptr) {
            return root1;
        } else {
            return root2;
        }
    }
};

700. 二叉搜索树中的搜索

力扣题目地址(opens new window)

给定二叉搜索树（BST）的根节点和一个值。你需要在 BST 中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在，则返回 NULL。

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* curr = root;
        while (curr != nullptr) {
            if (curr->val == val) {
                return curr;
            }
            if (curr->val < val) {
                curr = curr->right;
            } else {
                curr = curr->left;
            }
        }
        return nullptr;
    }
};

98. 验证二叉搜索树

力扣题目链接(opens new window)

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

想法：添加左右边界，需要防止直接使用 MAX

class Solution {
public:
    bool traversal(TreeNode* root, pair<int, bool> left, pair<int, bool> right) {
        if (!root) {
            return true;
        }
        if ((right.second && root->val >= right.first) ||
                (left.second && root->val <= left.first)) {
            return false;
        }
        return traversal(root->left, left, {root->val, true}) && traversal(root->right, {root->val, true}, right);
    }
    bool isValidBST(TreeNode* root) {
        return traversal(root, {INT_MIN, false}, {INT_MAX, false});
    }
};

中序遍历迭代法，好难，每次都忘了

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        int lastVal;
        bool hasLast = false;
        stack<TreeNode*> nodes;
        if (!root) {
            return true;
        }
        TreeNode* curr = root;
        while (curr || !nodes.empty()) {
            if (curr) {
                nodes.push(curr);
                curr = curr->left;
            } else {
                curr = nodes.top();
                nodes.pop();
                if (!hasLast) {
                    hasLast = true;
                } else if (curr->val <= lastVal) {
                    return false;
                }
                lastVal = curr->val;
                curr = curr->right;
            }
        }
        return true;
    }
};

顺便做了以下两道类似的题目：

235. 二叉搜索树的最近公共祖先

力扣题目链接(opens new window)

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q || !root) {
            return root;
        }
        if (p->val > q->val) {
            swap(p, q);
        }
        if (p->val < root->val && root->val < q->val) {
            return root;
        }
        if (p->val < root->val && q->val < root->val) {
            return lowestCommonAncestor(root->left, p, q);
        }
        return lowestCommonAncestor(root->right, p, q);
    }
};

701. 二叉搜索树中的插入操作

力扣题目链接(opens new window)

给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (!root) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if (root->val < val) {
            root->right = insertIntoBST(root->right, val);
        }
        if (root->val > val) {
            root->left = insertIntoBST(root->left, val);
        }
        return root;
    }
};

450. 删除二叉搜索树中的节点

力扣题目链接(opens new window)

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) {
            return nullptr;
        }
        if (root->val == key) {
            if (!root->left && !root->right) {
                delete root;
                return nullptr;
            }
            if (root->left && !root->right) {
                TreeNode* node = root->left;
                delete root;
                return node;
            }
            if (!root->left && root->right) {
                TreeNode* node = root->right;
                delete root;
                return node;
            }
            // root->left && root->right
            TreeNode* middle = root->right;
            while (middle->left) {
                middle = middle->left;
            }
            middle->left = root->left;
            TreeNode* node = root->right;
            delete root;
            return node;
        } else if (root->val < key) {
            root->right = deleteNode(root->right, key);
        } else {
            root->left = deleteNode(root->left, key);
        }
        return root;
    }
};

669. 修剪二叉搜索树

力扣题目链接(opens new window)

给定一个二叉搜索树，同时给定最小边界 L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。

原本考虑需要 Delete，所以必须后序遍历。

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (!root) {
            return nullptr;
        }
        TreeNode* left = trimBST(root->left, low, high);
        TreeNode* right = trimBST(root->right, low, high);
        if (low <= root->val && root->val <= high) {
            root->left = left;
            root->right = right;
            return root;
        } else if (low > root->val) {
            return right;
        } else {
            return left;
        }
    }
};

108. 将有序数组转换为二叉搜索树

力扣题目链接(opens new window)

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        int size = right - left;
        if (size == 0) {
            return nullptr;
        }
        if (size == 1) {
            return new TreeNode(nums[left]);
        }
        int split = size / 2 + left;
        TreeNode* curr = new TreeNode(nums[split]);
        curr->left = traversal(nums, left, split);
        curr->right = traversal(nums, split + 1,right);
        return curr;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

538. 把二叉搜索树转换为累加树

力扣题目链接(opens new window)

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

class Solution {
public:
    TreeNode* traversal(TreeNode* curr, int& sum) {
        if (!curr) {
            return nullptr;
        }
        traversal(curr->right, sum);
        curr->val += sum;
        sum = curr->val;
        traversal(curr->left, sum);
        return curr;
    }
    TreeNode* convertBST(TreeNode* root) {
        int sum = 0;
        return traversal(root, sum);
    }
};

144. 二叉树的前序遍历​

二叉树前序遍历的迭代法​

94. 二叉树的中序遍历​

二叉树中序遍历的迭代法​

145. 二叉树的后序遍历​

二叉树后序遍历的迭代法​

二叉树的统一迭代法​

102. 二叉树的层序遍历​

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

226. 翻转二叉树​

101. 对称二叉树​

104. 二叉树的最大深度​

222. 完全二叉树的节点个数​

110. 平衡二叉树​

257. 二叉树的所有路径​

404. 左叶子之和​

513. 找树左下角的值​

112. 路径总和​

113. 路径总和 ii​

106. 从中序与后序遍历序列构造二叉树​

105. 从前序与中序遍历序列构造二叉树​

654. 最大二叉树​

617. 合并二叉树​

700. 二叉搜索树中的搜索​

98. 验证二叉搜索树​

235. 二叉搜索树的最近公共祖先​

701. 二叉搜索树中的插入操作​

450. 删除二叉搜索树中的节点​

669. 修剪二叉搜索树​

108. 将有序数组转换为二叉搜索树​

538. 把二叉搜索树转换为累加树​

144. 二叉树的前序遍历

二叉树前序遍历的迭代法

94. 二叉树的中序遍历

二叉树中序遍历的迭代法

145. 二叉树的后序遍历

二叉树后序遍历的迭代法

二叉树的统一迭代法

102. 二叉树的层序遍历

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

226. 翻转二叉树

101. 对称二叉树

104. 二叉树的最大深度

222. 完全二叉树的节点个数

110. 平衡二叉树

257. 二叉树的所有路径

404. 左叶子之和

513. 找树左下角的值

112. 路径总和

113. 路径总和 ii

106. 从中序与后序遍历序列构造二叉树

105. 从前序与中序遍历序列构造二叉树

654. 最大二叉树

617. 合并二叉树

700. 二叉搜索树中的搜索

98. 验证二叉搜索树

235. 二叉搜索树的最近公共祖先

701. 二叉搜索树中的插入操作

450. 删除二叉搜索树中的节点

669. 修剪二叉搜索树

108. 将有序数组转换为二叉搜索树

538. 把二叉搜索树转换为累加树