Finding the k-th element in a BST
If you add a total count field to each node, you can find the k-th element efficiently (in logarithmic time) by writing a method like this (untested):

node *kth(int k)
{
    assert(k &gt;= 0 &amp;&amp; k &lt; total);

    if (left != NULL) {
        if (k &lt; left-&gt;total)
            return left-&gt;kth(k);
        k -= left-&gt;total;
    }

    if (k == 0)
        return this;

    assert(right != NULL);
    return right-&gt;kth(k - 1);
}


Otherwise, the recursive algorithm you used for findKthInorder is the most elegant way I can think of to do this.  I would clean it up a bit, though:

static const Node *kth_(const Node *node, int &amp;k)
{
    if (node == NULL)
        return NULL;

    const Node *tmp = kth_(node-&gt;left, k);
    if (tmp != NULL)
        return tmp;

    if (k-- == 0)
        return node;

    return kth_(node-&gt;right, k);
}

int kth(int k) const
{
    assert(k &gt;= 0);

    const Node *node = kth_(this, k);
    if (node == NULL) {
        std::cerr &lt;&lt; "kth: k is too large\n";
        exit(1);
    }

    return node-&gt;elem;
}


Returning a node pointer instead of an element from the helper function has two advantages:


We can use NULL to indicate failure.
We get to drop an argument from the helper function.
In the future, it will be easier to write a function to update the kth element.


In your findKthInOrder helper function, the k argument is never actually used, and can be dropped as well.

A couple cleanups on the side:


I renamed the class node to Node to avoid having to say mynode all over the place.  I suppose this is just a matter of taste, seeing how the STL uses lowercase type names.
I switched to zero-based indexing.  Again, this is a matter of taste, but zero-based indexing is far more common in C++, and is easier to work with in many cases.