1.遞增順序查詢樹

難度：簡單
給定一個樹，按中序遍歷重新排列樹，使樹中最左邊的結點現在是樹的根，並且每個結點沒有左子結點，只有一個右子結點。
示例 ：
輸入：[5,3,6,2,4,null,8,1,null,null,null,7,9]

       5
      / \
    3    6
   / \    \
  2   4    8
 /        / \ 
1        7   9

輸出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

1
  \
   2
    \
     3
      \
       4
        \
         5
          \
           6
            \
             7
              \
               8
                \
                 9  
 

提示：
給定樹中的結點數介於 1 和 100 之間。
每個結點都有一個從 0 到 1000 範圍內的唯一整數值。
思路：中序遍歷得到樹的元素(可用迭代也可用遞迴)，儲存在陣列中，然後建立新的樹。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* increasingBST(TreeNode* root) {
        vector<int> valSet;
        stack<TreeNode*> stack;
        while(root || !stack.empty()){  //迭代求得中序遍歷
            while(root){
                stack.push(root);
                root=root->left;
            }
            if(!stack.empty()){
                valSet.push_back(stack.top()->val);
                root=stack.top()->right;
                stack.pop();
            }
        }
        TreeNode* increBST=new TreeNode(valSet[0]);
        TreeNode* tempBST= increBST; 
        for(int i=1;i<valSet.size();i++){
            tempBST->right=new TreeNode(valSet[i]);
            tempBST=tempBST->right;
        }
        return increBST;
    }
};
 

改用遞迴，其實時間是差不多的，基本上一樣

/**
* Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* increasingBST(TreeNode* root) {
        vector<int> tempVal;
        inorderTraversal(root,tempVal);
        TreeNode* increBST=new TreeNode(tempVal[0]); //注意這裡需要new一個空間
        TreeNode* tempBST= increBST; 
        for(int i=1;i<tempVal.size();i++){
            tempBST->right=new TreeNode(tempVal[i]); //new 一個空間
            tempBST=tempBST->right;
        }
        return increBST;
      }
        void inorderTraversal(TreeNode* root,vector<int> &tempVal){ //遞迴中序遍歷得到樹的元素
            if(root->left!=NULL){//遍歷左子樹
                inorderTraversal(root->left,tempVal);
            }
            tempVal.push_back(root->val);//記錄根節點
            if(root->right!=NULL){//遍歷右子樹
                inorderTraversal(root->right,tempVal);
            }
        }
};
 

2.求根到葉子節點之和

難度：中等
給定一個二叉樹，它的每個結點都存放一個 0-9 的數字，每條從根到葉子節點的路徑都代表一個數字。
例如，從根到葉子節點路徑 1->2->3 代表數字 123。
計算從根到葉子節點生成的所有數字之和。
說明: 葉子節點是指沒有子節點的節點。

示例 1:
輸入: [1,2,3]

    1
   / \
  2   3

輸出: 25
解釋:
從根到葉子節點路徑 1->2 代表數字 12.
從根到葉子節點路徑 1->3 代表數字 13.
因此，數字總和 = 12 + 13 = 25.

示例 2:
輸入: [4,9,0,5,1]

    4
   / \
  9   0
 / \
5   1

輸出: 1026
解釋:
從根到葉子節點路徑 4->9->5 代表數字 495.
從根到葉子節點路徑 4->9->1 代表數字 491.
從根到葉子節點路徑 4->0 代表數字 40.
因此，數字總和 = 495 + 491 + 40 = 1026.

思路：很典型的一道題，也就是將每條路徑上的元素轉成string型別然後串聯起來，到達葉子節點後轉換成int型別push_back到容器中，再求和就行了，主要用到了遞迴實現深度優先搜尋。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if(root==NULL) return 0;
        vector<int> savePath;
        string str="";
        getSubPath(root,savePath,str);
        int sumNumber=0;
        vector<int>::iterator iter = savePath.begin();
	    while (iter != savePath.end()){
		     sumNumber += *iter++;   
        }
        return sumNumber;
    }
    void getSubPath(TreeNode* root, vector<int> &savePath, string str){
        str+=to_string(root->val);
        if(root->left==NULL && root->right==NULL) {
            savePath.push_back(stoi(str)); 
        }
        if(root->left!=NULL){
            getSubPath(root->left,savePath,str); //遞迴
        }
        if(root->right!=NULL){
            getSubPath(root->right,savePath,str);
        }
    }
};

3.驗證二叉樹

難度：中等
給定一個二叉樹，判斷其是否是一個有效的二叉搜尋樹。

假設一個二叉搜尋樹具有如下特徵：
節點的左子樹只包含小於當前節點的數。
節點的右子樹只包含大於當前節點的數。
所有左子樹和右子樹自身必須也是二叉搜尋樹。

示例 1:
輸入:

    2
   / \
  1   3

輸出: true

示例 2:
輸入:

    5
   / \
  1   4
     / \
    3   6

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

思路：遞迴的函式用得很巧，參考網上大神的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return isValidBST(root, LONG_MIN, LONG_MAX);
    }
    
    bool isValidBST(TreeNode *root, long mn, long mx) {　　//這個函式用得很巧
        if (!root) return true;
        if (root->val <= mn || root->val >= mx) return false;
        return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
    }
};