leetCode(46):Kth Smallest Element in a BST

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);

}