CareerCup

list *findX(list *root, int N, int X) {

int cnt=1;
// Assign start to root.
list *start=root;
list *node=root;

// Assuming that lenght is N and X < N, root will not be NULL
while(cnt++ < X) start=start->next;

while(start) {
start=start->next;
node=node->next;
}

// now node will be pointing to X the node
return node;
}

And complexity of above function is O(n).

Correct me if i'm wrong but since we'r trying to find the element thats X from the end, wont we use N-X in the while loop?
while (c++< (N-X))
and i'm assuming that that while loop encompasses the following while(start) in its loop?

Above solution is correct, Just trying different ways of doing a given problem

NODE FindK(NODE node,int k)
{
static int i;
if(NULL == node)
.....return NULL;
FindK(node->next,k);
if(k-1 == i)
.....return node;
i++;
return NULL;
}

There is no way to get it -- linked list and from the end? End-->next is always NULL?

2 cases :
if lenght N is given as in q above :

struct node*ptr=head;
int c=0;

while(c++<N-X)
{
if(ptr->next==NULL)return NOT FOUND;

ptr=ptr->next;
}

return ptr;



if N is not given we use 2 ptrs.

struct node* ptr=head;
struct node* retv=head;
int c=0;
while(c++<X)
ptr=ptr->next;

while(ptr->next!=NULL)
{
ptr=ptr->next;
retv=retv->next;

}

return retv;

This should how much legacy code bloomturd has.