Leetcode (+): Kth smallest Element in a BST

Given A binary search tree, write a function to kthSmallest find the k-th smallest element in it.

Note:
You may assume k are always valid, 1≤k≤bst's total elements.

Intuitively, looking for a small number of k, is not traversing to the number k? So the middle sequence traversal is easy to think of, as follows:

/** * 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++;//minor modifications to the middle order traversal    Kthvalue = tmp->val;    TMP = tmp->right;    }    return kthvalue;}    ;

In addition, looked at the answer of the netizen, very ingenious. He is the first to count the number of nodes on the left subtree, if the number of nodes is less than k, in the right sub-tree to find the k-n-1 small number, if just K is the current node, if greater than K, then continue to find the number K small on the left subtree. However, each recursive to count the number of nodes, will it lead to increased complexity?

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

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Leetcode (+): Kth smallest Element in a BST