算法分析-查找单链表中的倒数第k个元素和中间元素

题目表述：

 

1.设计一个算法，找出一个无环的单链表里面倒数第k个元素，速度要快。

2.设计一个算法，找出一个无环的单链表里中间元素

 

1.算法实现：

 

实现中的注释已经解释了算法的大概思想。

 

[cpp]  view plain copy print ?

1. struct node{  
2.     int key;  
3.     node* next;  
4. };  
5. typedef node* List;  
6. int findLastKthElement(List list, int k)  
7. {  
8.     //遍历整个链表，  
9.     //声明一个临时指针指向头节点  
10.     //当遍历过元素个数小于K的时候，继续遍历  
11.     //当遍历过的元素个数等于k的时候，临时指针指向下一个元素，然后继续遍历  
12.     //当遍历到链表尾部的时候，则临时指针指向的节点就为倒数第k个元素。  
13.     if (list == NULL || k <= 0)  
14.     {  
15.         return -1;   //查找失败。  
16.     }  
17.     List p = list;  
18.     List tempList = list;  
19.     int num = 0;  
20.     while(p)  
21.     {  
22.         if (num < k)  
23.         {  
24.             num++;  
25.         }  
26.         else if (num == k)  
27.         {  
28.             tempList = tempList->next;  
29.         }  
30.         p = p->next;  
31.     }  
32.       
33.     if (num < k)  
34.     {  
35.         return -1; //查找倒数第k个元素失败  
36.     }  
37.     return  tempList->key;  
38. }  

2.其实这类问题都可以设置两个指针，比如二个问题，可以设置两个指针，同时从头开始遍历，一个快指针同时走两步，一个慢指针一次走一步，当快指针走到尾部时，则慢指针就到中间了。

1 ListNode* find_midlist(ListNode* head)
 2 {
 3     ListNode *p1, *p2;
 4     
 5     if (head == NULL || head->next == NULL)
 6     {
 7         return head;
 8     }
 9     p1 = p2 = head;
10     while (1)
11     {
12         if (p2->next != NULL && p2->next->next != NULL)
13         {
14             p2 = p2->next->next;
15             p1 = p1->next;
16         }
17         else
18         {
19             break;
20         }
21     }
22     return p1;
23 }