CareerCup

@ ketan :
this is relevant to c++
Base is the parent class and Derived is the child class ..

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

typedef struct tree
{
int data;
struct tree* left;
struct tree* right;
}TREE;


TREE* createNode(int x)
{
TREE *ptr;
ptr=(TREE*)malloc(sizeof(TREE));
ptr->data=x;
ptr->left=NULL;
ptr->right=NULL;
return ptr;
}






void kthLargest(TREE *root,int *kth,int k)
{
static int counter=0;
if(root==NULL)
return;
else
{



kthLargest(root->left,kth,k);
counter=counter+1;
if(k==counter)
{
*kth=root->data;
return;

}

printf("%d",counter);
kthLargest(root->right,kth,k);


}


}
int getCount(TREE *ptr)
{
if(ptr==NULL)
return 0;
else
return 1+getCount(ptr->left)+getCount(ptr->right);

}

TREE *root;
void initialize()
{
root=NULL;
}

int main()
{

initialize();
root=createNode(8);
root->left=createNode(6);
root->right=createNode(11);
root->left->left=createNode(5);
root->left->right=createNode(7);
root->left->left->left=createNode(4);
root->right->left=createNode(10);
root->right->right=createNode(13);
int kth,k;
k=5;
kth=0;
kthLargest(root,&kth,getCount(root)-k+1);
printf("\n the kth largest number =%d",kth);
return 0;

}

use #pragma pack(1)

vertex --> geometry ->pixel shaders ........

@ sri : what if the values are greater ..say 1000 ,or greater ..
bit vector would work for numbers until 32 or 64 .....

#include <string.h>

#include <stdlib.h>

int main(int argc, char* argv[])
{
//char ***p=**p=*p="hello";
int Hash[255];
char str[]="lxkfjglk jpdjhpfsjhrtjgv jth0t9jhy";
//memset(Hash,1,255);
int i;
for(i=0;i<255;i++)
{
Hash[i]=0;

}

for(i=0;str[i]!='\0';i++)
{
printf("\t\t %d",str[i]);
Hash[str[i]]=Hash[str[i]]+1;
printf("--> %d",Hash[str[i]]);

}
printf("hash=%d",Hash[0]);
int t=0;
for(i=0;str[i]!='\0';i++)
{
if(Hash[str[i]]>1)
{
printf("\n the first non repeating element is=%c",str[i]);

t=1;

}
if(t==1)
break;


}

return 0;

}

i think this method would also work......
if(time_elapsed_in_seconds%X==0 && counter<N)
return true;
else
return false;

if the data in the linked is within limited range ..then we can optimise search ...by using Hash.........in O(1) time ....

void kthLargest(TREE *ptr,int kth)
{
static int k=0;
if(ptr==NULL)
return ;
else
{
kthLargest(ptr->left,kth);
k=k+1;
if(k==kth)
printf("the kth largest element=%d",ptr->data);
kthLargest(ptr->right,kth);

}
}

a BST has minimum element in the leftmost .. & maximum in the right most ...... just take these two and
just check min < element in the tree <max