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.

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?

[qestion](https://leetcode.com/problems/kth-smallest-element-in-a-bst/#/description , question)

解法：

1. 通过in-order排序将node变成一个array arr[k]就会是答案
   while， 在follow up 里面，出现的问题在于如果频繁的isnert和delete的话时间上就hold不住，每次insert or add之后都会出现需要重新in order的问题，假设我们insert n次，那么我们的时间总长就会变成n²,which is pretty bad

2.我使用的是这个解法，只是个思路，但是确实可行，需要改变binary tree的结构实现

class Solution(object):
    def totalnode(self,root):
        if not root.right and not root.left:
            return 1
        else:
            l,r = 0, 0
            if node.right:
                r = self.totalnode(node.right)
            if node.left:
                l = self.totalnode(node.left)
            return 1+l + r

    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if k == 0:
            return root.val
        l = 0
        if root.left:
            l = self.totalnode(l)

        if k ==  l+1:
            return root.val
        if k > l+1:
            return kthSmallest(self, root.right, k-l+1)
        else:
            return kthSmallest(self, root.right, k-1)

简单来说用total-node function来计算某棵树总共有多少node，
先计算左边总共有多少node，如果k > lefttotal,那么说明k在树杈的右边，反之就说明他在树叉的左边，但这样的时间复杂度相当的高指数性的，

但是，如果改变binary tree的结构的话，就能够让他的time complexity压缩到n，

具体：
正常的tree

struct tree{
  int val
  tree left
  tree right
}

但是可以加两个属性

struct tree{
  int val
  tree left
  int lefttotal
  tree right
  int righttotal
}

通过两个值来承载左边的总数和右边的总数，
具体操作是通过insert上每次insert进入更低层的时候，根据她进入的方向，增加值，
这样就不需要花时间来calculate total这两个值，但是使用的时候却异常方便

leetcode没把法改变固有结构，所以没办法实现，但是这种tree实现起来其实也很简单。