1.相同的树

给定一个二叉树，编写一个函数来检验他们是否相同。

思路：递归

2.对称的树

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

思路：递归法同上一题
迭代法：用队列进行迭代，左子树按照先左后右的顺序入队，右子树按照先右后左的顺序入队

3.二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远子节点的路径上的节点数.

思路：递归
非递归用队列：BFS（广度优先按搜索）访问每一层节点，同时在每次访问时更新最大深度。

int maxDepth(TreeNode* root) {
        queue<TreeNode*> q;
        TreeNode* node;
        q.push(root);
        
        int cur = 1;    //当前层还未遍历节点的个数
        int next = 0;    //下一层节点的个数
        int level = 0;     //遍历的层数
        
        while(!q.empty())
        {
            node = q.front();
            q.pop();
            cur--;
            
            if(node -> left != nullptr)
            {
                q.push(node -> left);
                next++;
            }
            if(node -> right != nullptr)
            {
                q.push(node -> right);
                next++;
            }
            if(cur == 0)
            {
                cur = next;
                next = 0;
                level++;
            }
        }
        return level;
    }

4.二叉树的层次遍历II

给定一个 二叉树，返回其节点自底向上的层次遍历（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：与上一题BFS思路一样

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

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

思路：类似于分治法递归建立二叉树

TreeNode* makeTree(vector<int>& nums, int start, int end)   //start和end为下标
    {
        int mid = (start + end) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        if(start < end)
        {
            if(mid == start)
            {
                root -> left = nullptr;
                root -> right = makeTree(nums, mid + 1, end);
            }
            else if(mid == end)
            {
                root -> left = makeTree(nums, start, mid - 1);
                root -> right = nullptr;
            }
            else
            {
                root -> left = makeTree(nums, start, mid - 1);
                root -> right = makeTree(nums, mid + 1, end);
            }
        }
        else
        {
            root -> left = nullptr;
            root -> right = nullptr;
        }
        return root;   
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size() == 0)
        {
            return {};
        }
        return makeTree(nums, 0, nums.size()- 1);
    }

6.平衡二叉树

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

思路：递归判断左右子树的高度

int height(TreeNode* root)
    {
        if(root == nullptr)
        {
            return 0;
        }
        return 1 + max(height(root -> left), height(root -> right));
    }
    bool isBalanced(TreeNode* root) {
        if(root == nullptr)
        {
            return true;
        }
        int left = height(root -> left);
        int right = height(root -> right);
        if(left - right > 1 || left - right < -1)
        {
            return false;
        }
        return isBalanced(root -> left) && isBalanced(root -> right);
    }

7.二叉树的最小深度

给定一个二叉树，找到其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

递归

int minDepth(TreeNode* root) {
        if(root == nullptr)
        {
            return 0;
        }
        if(root -> left != nullptr && root -> right != nullptr)
        {
            return 1 + min(minDepth(root -> left), minDepth(root -> right));
        }
        else
        {
            return 1 + minDepth(root -> left) + minDepth(root -> right);
        }
    }

8. 路径总和

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

递归

bool hasPathSum(TreeNode* root, int sum) {
        if(root == nullptr)
        {
            return false;
        }
        //终止条件——叶子节点
        if(root -> left == nullptr && root -> right == nullptr)
        {
            return sum - root->val == 0;
        }
        return hasPathSum(root -> left, sum - root->val) || hasPathSum(root -> right, sum - root->val);
    }

9.翻转二叉树

递归

TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr)
        {
            return root;
        }
        TreeNode* temp = root -> left;
        root -> left = root -> right;
        root -> right = temp;

        invertTree(root -> left);
        invertTree(root -> right);

        return root;
    }