230. Kth Smallest Element in a BST（python+cpp）

题目：

Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.
Note: You may assume k is always valid, 1 ≤ k ≤ BST's total elements.
Example 1:

Input: root = [3,1,4,null,2], k = 1    
  3   
 / \  
1   4  
 \    
 2
Output:1

Example 2:

Input: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \    
   2   4   
  /  
 1 
Output: 3

Follow up:
What if the BST is modified (insert/delete operations) often and you need to find the kth smallest frequently? How would you optimize the kthSmallest routine?

解释：
返回一颗BST中第K大的数字，由于是BST，直接中序遍历就能返回有序数组，而且不需要遍历完再取值，用一个计数器记录当前取到了第几个值即可，善用判断条件可以减少递归时间。
python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        self.count=0
        self.res=0
        def middle(root):
            if self.count<k:
                if root.left:
                    middle(root.left)
                self.count+=1
                if self.count==k:
                    self.res=root.val
                    return
                if root.right:
                    middle(root.right)
        if root:
            middle(root)
        return self.res

c++代码：

/**
 * 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 count=0;
    int res=0;
    int kthSmallest(TreeNode* root, int k) {
        if(root)
            dfs(root,k);
        return res;
    }
    void dfs(TreeNode* root,int k)
    {
        if(count<k)
        {
            if (root->left)
                dfs(root->left,k);
            count++;
            if (count==k)
            {
                res=root->val;
                return;
            }
            if(root->right)
                dfs(root->right,k);
        }
    }
};

总结：
看到BST就想到中序遍历，在遍历的过程中比较无需全部遍历完成再做处理。