１．二叉樹的最大深度
給定一個二叉樹，找出其最大深度。

二叉樹的深度為根節點到最遠葉子節點的最長路徑上的節點數。

說明: 葉子節點是指沒有子節點的節點。

示例：
給定二叉樹 [3,9,20,null,null,15,7]，

　　 3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

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

2.驗證二叉搜尋樹
給定一個二叉樹，判斷其是否是一個有效的二叉搜尋樹。

假設一個二叉搜尋樹具有如下特徵：

節點的左子樹只包含小於當前節點的數。
節點的右子樹只包含大於當前節點的數。
所有左子樹和右子樹自身必須也是二叉搜尋樹。
示例 1:

輸入:

 　 2
   / \
  1   3

輸出: true
示例 2:

輸入:

　  5
   / \
  1   4
     / \
    3   6

輸出: false
解釋: 輸入為: [5,1,4,null,null,3,6]。
根節點的值為 5 ，但是其右子節點值為 4 。

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root)   return true;
        vector<int> res;
        inorder(root,res);
        for(int i=1;i<res.size();i++)
            if(res[i-1] >= res[i])
                return false;
        return true;
    }
    
    void inorder(TreeNode* root,vector<int>& res)
    {
        if(!root) return;
        inorder(root->left,res);
        res.push_back(root->val);
        inorder(root->right,res);       
    }
};
 

3.對稱二叉樹
給定一個二叉樹，檢查它是否是映象對稱的。

例如，二叉樹 [1,2,2,3,4,4,3] 是對稱的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面這個 [1,2,2,null,3,null,3] 則不是映象對稱的:

    1
   / \
  2   2
   \   \
   3    3

說明:

如果你可以運用遞迴和迭代兩種方法解決這個問題，會很加分。

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)   return true;
        return duichen(root->left,root->right);
    }
    bool duichen(TreeNode* leftnode,TreeNode* rightnode)
    {
        if(!leftnode && !rightnode)
            return true;
        if(leftnode && rightnode && leftnode->val == rightnode->val)
            return duichen(leftnode->left,rightnode->right) && duichen(leftnode->right,rightnode->left);
        return false;
    }
};
 

4.二叉樹的層次遍歷
給定一個二叉樹，返回其按層次遍歷的節點值。 （即逐層地，從左到右訪問所有節點）。

例如:
給定二叉樹: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其層次遍歷結果：
[
[3],
[9,20],
[15,7]
]

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

5.將有序陣列轉換為二叉搜尋樹
將一個按照升序排列的有序陣列，轉換為一棵高度平衡二叉搜尋樹。

本題中，一個高度平衡二叉樹是指一個二叉樹每個節點 的左右兩個子樹的高度差的絕對值不超過 1。

示例:

給定有序陣列: [-10,-3,0,5,9],

一個可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面這個高度平衡二叉搜尋樹：

      0
     / \
   -3   9
   /   /
 -10  5
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.empty())
            return nullptr;
        TreeNode* root = new TreeNode(nums[nums.size()/2]);
        vector<int> vec_l = vector<int>(nums.begin(),nums.begin()+nums.size()/2);
        vector<int> vec_r = vector<int>(nums.begin()+nums.size()/2+1,nums.end());
        root->left = sortedArrayToBST(vec_l);
        root->right = sortedArrayToBST(vec_r);
        return root;
    }
};