Have two pointers with a difference of n. When pointer1 is at head, pointer2 is at element n from the head. Traverse the list moving pointer1 and pointer2 until pointer2 reaches end of the list at which case pointer1 is pointing to element at N from end.

Node node1 = root; Node node2 = node1; while (num-- > 0) { node2 = node2.getNext(); } while(node2 != null) { node1 = node1.getNext(); node2 = node2.getNext(); } System.out.println("\n\n Last 5th number is : " + node1.getValue());

static List returnNode = null;//define as class scope variable //for this recursive call, very last node (null) return 0, and all preceding nodes gets 1+ higher indexes static int FindNthLast(List L, int N) { if (L == null) return 0; else { int nextLastIndex = FindNthLast(L.Next, N); //If we found the Nth last node, we need assign List value to class-scope returnNode if (nextLastIndex + 1 == N) returnNode = L; return 1 + nextLastIndex; } } //after executing FindNthLast(List, N), returnNode.value is the nth last value we are looking for in the List

The problem here is that we can only start from the head to tail. The previous code is one of the solutions. Another non-recursive solution is that reverse that linked list (http://www.mytechinterviews.com/reverse-a-linked-list) then perform a simple scan to get the nth number from the head. I guess the running time for my solution is O(n).

Traverse twice through the LL. The first pass will return number of elements. The second pass with the number of an element (starting from zero) subtracted from the size of the list will find the Nth element. O(n). Why make it too complicated?