CareerCup

int kthlargest(node *root,int k)
{
static int count =0;
	if(root == NULL)
	return;
	kthsmallest(root->right,k);
	count++;
		if(k==count)
		return root->data;
	kthlargest(root->left,k);
}

Perform reverse in-order traversal of the given BST and return when the k-th element is found.

int count = 0; 
Stack S;
while n != null) {
    S.push(n);
    n = n.right;
}

while (S.size() > 0) {
    n = s.pop();
    count++;
    if (count == k) {
        return n.value;
    }
    if n.left != null) {
        n = n.left;
        while (n!= null) {
             s.push(n);
             n = n.left;
        }
    }
}

System.out.println("ERROR : k > numver of nodes in the tree");

void getKthLargestElement(Node *root, int k){
	int num = 0;
	count(root, &num);
	getKthSmallestElement(root,num-k+1,num);
}
//To find kth smallest element in in BST
void getKthSmallestElement(Node *root, int k, int num){
   static int count, found;
   if(root && !found ){	
         getKthSmallestElement(root->left, k, num);
         count++;
         if(count == k){
	        printf("%d",root->data); found =1; return; 
         }
         else if(count == num && !found){
	        printf("\nData not found"); return;
         }
         getKthSmallestElement(root->right, k, num);
   }
}
void count(Node *root, int *p){	
	if(root){
		count(root->left, &(*p));
		(*p)++;
		count(root->right, &(*p));
	}
}

No recursion, beat that.
And traverses as minimum nodes as required.

private static int getKthLargest(TreeNode root , int k) {
		int fixedIndex=0;
		List<TreeNode> list = new ArrayList<TreeNode>();
		fillRightSideNodes(list,root,fixedIndex);
		while(fixedIndex<=list.size()){
			if ( fixedIndex>=list.size()){return -1;}
			if ( fixedIndex==k-1){return list.get(fixedIndex).getValue();}
			fillRightSideNodes(list,list.get(fixedIndex).getLeftSubTree(), fixedIndex+1);
			fixedIndex++;
		}
		return -1;
	}
	private static void fillRightSideNodes(List<TreeNode> list, TreeNode root,
			int index) {
		while ( root != null ){
			list.add(index,root);
			root=root.getRightSubTree();
		}
	}

public static void findKthElement(Tree node , int k)
{
if(node == null)
{
System.out.println("TREE NULL");
return;
}
Stack<Tree> stack = new Stack<>();
int n =0 ;
while(true)
{
while(node != null)
{
stack.add(node);
node = node.right;
}
if(stack.isEmpty())
{
System.out.println("ELEMENT COUNT OUT OF RANGE");
return;
}
node = stack.pop();
n++;
if(n == k)
{
System.out.println("THE KTh ELEMENT: "+ node.getValue());
return;
}
node = node.left;
}
}

TreeNode kthLargest(TreeNode t, int k) {
    if (t == null){
        return null;
    }
    return kthLargest(t.right, k);
    k--;
    if (k == 0){
        retrun t;
    }
    return kthLargest(t.left, k);
}

struct Node {
int value;
Node *left;
Node *right;
};

//return: true find, false not find
//param:
// count: the number of nodes in the subtree
// ans: the kth largest number
bool find_kth_large(Node *root, int k, int &count, int &ans)
{
if (NULL == root) {
count = 0;
return false;
}
int right_count = 0;
if (find_kth_large(root->right, k, right_count, ans)) {
return true;
}
if (right_count + 1 == k) {
ans = root->value;
return true;
}
int left_count = 0;
if (find_kth_large(root->left, k - 1 - right_count, left_count, ans)) {
return true;
}
count = left_count + right_count + 1;
return false;
}

struct tree *kthlargBST(struct tree*root,int k)
{
if(k!=0 && root==NULL)
return;
kthlargBST(root->right,k--)
if(k==0)
return root;
kthlargBST(riit->left,k--);


}

augmenting the bst can also work. The bst should be augmented with the total no of children in its tree

def find_largest_element(node, k)
  return nil unless node
  index = 0
  find_largest_element(node.right, k)
  if ++index == k
    return node.data
  end
  find_largest_element(node.right, k)
end

class KthLargestBST{
	protected static int findKthLargest(BSTNode root,int k){
		int [] result=findKthLargest(root,k,0);
		return result[1];//the element we are looking for.
	}
	private static int[] findKthLargest(BSTNode root,int k,int count){//returns an array containing 2 ints..one for counts and the other for result.
		if(root==null){
			int[]  i=new int[2];
			i[0]=-1;
			i[1]=-1;
			return i;
		}else{
			int rval[]=new int[2];
			int temp[]=new int[2];
			rval=findKthLargest(root.rightChild,k,count);
			if(rval[0]!=-1){
				count=rval[0];
			}
			count++;
			if(count==k){
				rval[1]=root.data;
			}
			temp=findKthLargest(root.leftChild,k,(count));
			if(temp[0]!=-1){
				count=temp[0];
			}
			if(temp[1]!=-1){
				rval[1]=temp[1];
			}
			rval[0]=count;
			return rval;
		}
	}
	public static void main(String args[]){
		BinarySearchTree bst=new BinarySearchTree();
		bst.insert(6);
		bst.insert(8);
		bst.insert(7);
		bst.insert(4);
		bst.insert(3);
		bst.insert(4);
		bst.insert(1);
		bst.insert(12);
		bst.insert(18);
		bst.insert(15);
		bst.insert(16);
		bst.inOrderTraversal();
		System.out.println();
		System.out.println(findKthLargest(bst.root,7));
	}

}

Some people already did this using C and a static counter. This is using Java and no counter.

This is just a right leaning in-order traversal.
When the counter becomes zero we are done.

void printKthLargest(Node n, int k) {
	if( n==null)
		return ;//reached root's parent

	printKthLargest(n.right, k);
	if( k == 0) {
		System.out.println(k);
		return;
	}
	k--;
	printKthLargest(n.left, k);	

}