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.

直观地一想。查找第k小的数，不就是遍历到第k个数吗？所以中序遍历非常easy想到，例如以下：

/**

 * 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 kthSmallest(TreeNode* root, int k) {

    	stack<TreeNode*> nodeStack;

    	TreeNode* tmp=root;

    	int kthMin = 0;

    	int kthValue;

    	while ((!nodeStack.empty() || tmp!=NULL) && kthMin!=k)

    	{

    		while (tmp != NULL)

    		{

    			nodeStack.push(tmp);

    			tmp = tmp->left;

    		}

    		tmp = nodeStack.top();

    		nodeStack.pop();

    		kthMin++;//对中序遍历稍加改动

    		kthValue = tmp->val;

    		tmp = tmp->right;

    	}

    	return kthValue;

    }

};

另外。看了一下网友的解答，很巧妙。

他是先统计左子树上节点个数，假设节点个数小于k。则在右子树上找第k-n-1小的数，假设刚为k则就是当前节点，假设大于k，则继续在左子树上找第k小的数。

只是。每次递归都要统计一次节点个数，会不会导致复杂度添加？

int kthSmallest(TreeNode* root, int k) {

    if (!root) return 0;

    if (k==0) return root->val;

    int n=count_size(root->left);

    if (k==n+1) return root->val;

    if (n>=k){

        return kthSmallest(root->left, k);

    }

    if (n<k){

        return kthSmallest(root->right, k-n-1);

    }

}

int count_size(TreeNode* root){

    if (!root) return 0;

    return 1+count_size(root->left)+count_size(root->right);

}