CareerCup

if(head==null) return null;

Start with two pointers.
P1 and P2 pointing at the head.
keeping p1 at the position, increment p2 n times. (During the process, if anywhere p2 points to null, return null).
Now increment p1 and p2 together until p2->next == null.
p1 points to the nth node from the nth node from last.
regards.

struct node* getNthLast(struct node* head,int n)
{
   struct node *tmp1, *tmp2;
   tmp1=tmp2=head; 

while(tmp2)
  { if(n>0) 
     {
      tmp2=tmp2->next; 
      n--;
     }
    else
     { 
        tmp1=tmp1->next;
        tmp2=tmp2->next;
     }
    }
   return tmp1;

p1 points to the nth node from last. (last sentence in the comment above)

include int n in the parameter list

Keep a queue of fixed size n and loop through the linked list. As you get each node perform the following operations enqueue the current node in the end and dequeue the first element if it is full.

Precisely the pseudo code should look like:

FetchNthFromEnd (node top)
begin
queue q(n)
while(top is not null)
loop
enqueue(q,top) // it should handle the case when the queue is full, in that case the first element should be dequeued and then new element should be enqueued.
next(top)
endloop
return dequeue(q)
end

enqueue and dequeue both are O(1) so it is O(N).

Traverse the linked list and put the node in the stack until null.
Now pop out nodes from the stack and count until n is reached. That the node to look for. If stack is empty before n reached, return NULL

// Find tail
struct node* findTail(struct node* head)
{
	struct node* tail = NULL;	
	while(head != NULL)
	{
		tail = head;
		head = head->next;
	}
	return tail;
}

Start with 2 pointers. P1 and P2.

P1 increments by 1, P2 increments by 2.
When P2 reaches end. You'll know the total number of elements in the list.
And P1 is halfway. Calculate from P2 and move P1 forward or backward accordingly.