实现这个算法，可以用递归和非递归。因为单向链表只能向后遍历，所以一般会想到用递归这种方法，然后当递归遍历到链表末端时，该方法会回传一个置为0的计数器。

之后的每一次调用都会将这个计数器加1，当计数器等于K时，表示我们访问的是链表倒数第K个元素。

方法A

1. public static int nToLast(LinkedListNode head,int k){  
2.     if(head==null){  
3.         return 0;  
4.     }  
5.     int i = nToLast(head.next,k)+1;//当遍历到最后一个元素时，计数器i开始自增。
6.     if(i==k){  
7.         System.out.println(head.data);  
8.     }  
9.     return i;  
10. }  

但是这个方法只能打印倒数第K个值，不能返回该元素，因为我们无法用一般的返回语句回传一个结点和一个计数器。

用一个简单的类包装计数器值，就可以模仿按引用传值。

1. public class MyCount  
2. {  
3.     public int value = 0;     
4. }  
5. LinkedListNode nToLast(LinkedListNode head,int k,MyCount i){  
6.     LinkedListNode node = nToList(head.next,k,i);  
7.     i.value = i.value+1;  
8.     if(i.value == k){  
9.         return head;  
10.     }  
11.     return node;  
12. }  

迭代法，一个更直接的方法，我们可以使用两个指针p1和p2，并将他们指向链表中相距k个结点的两个结点，具体做法是将p1和p2指向链表首结点，然后将 p2向后移动k个结点，之后，我们以相同的速度移动这两个指针，p2会在移动length-k步后抵达链表末尾结点，这时，p1就指向链表倒数第k个结 点。

1. LinkedListNode nToList(LinkedListNode head,int k){  
2.     if(k<=0)  
3.         return null;  
4.     LinkedListNode p1 = head;  
5.     LinkedListNode p2 = head;  
6.   
7.     for(int i=0;i<k-1;i++){  
8.         if(p2==null)   
9.             return null;  
10.         p2 = p2.next;  
11.     }  
12.     if(p2==null)  
13.         return null;  
14.     while(p2.next!=null){  
15.         p1 = p1.next;  
16.         p2 = p2.next;  
17.     }  
18.     return p1;  
19. }  

或者

1. class Node{  
2.    Node(int value, Node nnode){  
3.       this.value=value;  
4.       this.nnode=nnode;  
5.    }  
6. }  

1. public static Node findknode(Node head, int k){  
2.   if ((Null==head) || (Null==head.nnode))  
3.       return head;  
4.   cur=head;  
5.   knode=head;  
6.   nextnode=Null;  
7.   count=0;  
8.   while(cur!=Null){  
9.      count+=1;  
10.      if(count>=k){  
11.          nextnode=knode.nnode;  
12.          knode=nextnode;  
13.       }  
14.      nextnode=cur.nnode;  
15.      cur=nextnode;  
16.   }  
17.   return knode;  
18. }