题目：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。（尾节点为倒数第0个节点，有头节点，头节点数据为空，尾节点数据不为空）

链表结点定义如下：

1. struct ListNode  
2.  {   
3.     int m_nKey;   
4.     ListNode* m_pNext;   
5. };  

思路一：遍历整个链表，找到链表中节点的个数，根据节点个数能够确定倒数第k个节点从头开始数的序号，从而找到倒数第k个节点

1. ListNode *Find(ListNode* head,int k)  
2. {  
3.     int num=0;//除去头  节点个数  
4.     ListNode *now=head;  
5.     while(now->m_pNext!=NULL)  
6.     {  
7.         now=now->m_pNext;  
8.         num++;  
9.     }  
10.     if(num<k)  
11.         return NULL;  
12.     now=head;  
13.     for(int i=0;i<num-k;i++)  
14.         now=now->m_pNext;  
15.     return now;  
16. }  

思路二：如果我们在遍历时维持两个指针，第一个指针从链表的头指针开始遍历，在第k-1步之前，第二个指针保持不动；在第k-1步开始，第二个指针也开始从链表的头指针开始遍历。由于两个指针的距离保持在k-1，当第一个（走在前面的）指针到达链表的尾结点时，第二个指针（走在后面的）指针正好是倒数第k个结点。

1. ListNode * Find2(ListNode *head,int k)  
2. {  
3.     ListNode *ahead=head;  
4.     ListNode *after=head;  
5.     for(int i=0;i<k;i++)  
6.     {     
7.         if(ahead->m_pNext!=NULL)  
8.         ahead=ahead->m_pNext;  
9.         else 
10.             return NULL;  
11.     }  
12.     while(ahead->m_pNext!=NULL)  
13.     {  
14.         ahead=ahead->m_pNext;  
15.         after=after->m_pNext;  
16.     }  
17.     return after;  
18. }  
19. void main()  
20. {  
21.     ListNode a[7];  
22.     a[0].m_pNext=&a[1];  
23.     a[1].m_nKey=1;  
24.     a[1].m_pNext=&a[2];  
25.     a[2].m_nKey=2;  
26.     a[2].m_pNext=&a[3];  
27.     a[3].m_nKey=3;  
28.     a[3].m_pNext=&a[4];  
29.     a[4].m_nKey=4;  
30.     a[4].m_pNext=&a[5];  
31.     a[5].m_nKey=5;  
32.     a[5].m_pNext=&a[6];  
33.     a[6].m_nKey=6;  
34.     a[6].m_pNext=NULL;  
35.     cout<<Find(&a[0],1)->m_nKey<<endl;  
36. }