解题笔记（13）——几个链表的问题

      链表的一些问题经常会在面试中出现，这类题目能很好的反映出程序员的编程基本功，以及思维的缜密程度。写代码之前，最好能仔细分析一下题目，列出关键点。其实思路是最重要的，思路如果正确，代码实现不是问题，更像是一个翻译的过程。下面是4道关于链表的题目，网上都有思路解答。自己实现了一下，供网友参考。下面各题的链表结点定义如下：

[cpp]  view plain copy print ?

1. struct ListNode  
2. {  
3.     int key;  
4.     ListNode *next;  
5.     ListNode(int k = 0, ListNode *p = NULL) { key = k; next = p;}  
6. };  

        问题1：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点。

    思路：可以定义两个辅助指针，一个指向当前结点，设为pCur；一个指向前一个结点，设为pPrev，然后反转 pCur->next = pPrev。但是原来的pCur->next丢失了。可以再定义一个辅助指针pNext，用来保存这个值。另外就是一些为空的判断，需要加倍小心。

    参考代码：

[cpp]  view plain copy print ?

1. ListNode* ReverseList(ListNode *pHead)  
2. {  
3.     ListNode *pPre = NULL;  
4.     ListNode *pCur = pHead;  
5.   
6.     //开始反转  
7.     while(pCur != NULL)  
8.     {  
9.         ListNode *pNext = pCur->next; //临时保存下一个结点  
10.           
11.         //关键的三步  
12.         pCur->next = pPre;  //反转  
13.         pPre = pCur;        //保存上一个结点  
14.         pCur = pNext;       //更新当前结点  
15.     }  
16.     return pPre;  //pPre变为第一个结点  
17. }  

    问题2：输入一个链表的头结点，从尾到头反过来输出每个结点的值。

    思路：有很多解法，网上常见的有三种，一般都能想到。（1）可以利用问题1的结果，反转链表，然后再输出。（2）用递归实现。（3）用栈，其实与解法2相似，递归的本质其实就是栈的思想。给出后两种解法的代码。

    参考代码：

[cpp]  view plain copy print ?

1. //栈实现  
2. void ReorderPrint_Solution1(ListNode * pHead)  
3. {  
4.     stack<int> keyStack;  //结点的数据栈    
5.     ListNode *pNode = pHead;  
6.   
7.     while(pNode != NULL)  //将链表的数据压栈  
8.     {  
9.         keyStack.push(pNode->key);  
10.         pNode = pNode->next;  
11.     }  
12.     while(keyStack.size() > 0) //出栈  
13.     {  
14.         cout<<keyStack.top()<<' ';  
15.         keyStack.pop();  
16.     }  
17. }  
18. //递归实现  
19. void ReorderPrint_Solution2(ListNode * pHead)  
20. {  
21.     if(pHead == NULL)  
22.         return;  
23.     else  
24.     {  
25.         ReorderPrint_Solution2(pHead->next);  
26.         cout<<pHead->key<<' ';  
27.     }  
28. }  

    问题3：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。

    思路：《编程之美》有这道题，采用了一种“狸猫换太子”的方法，非常形象。真正删除的是下一个结点，同时将原删除结点的数据项设为下一个结点的数据项。《编程之美》中假定删除结点不是第一个结点，也不是最后一个结点。本问题中，没有这个限制，如果是删除的最后结点。只能从头遍历，找到前驱结点。但是平均的时间复杂度为O(1)。

    参考代码：以下代码基于删除结点一定在链表中这个假设。

[cpp]  view plain copy print ?

1. ListNode* DeleteNode(ListNode* pHead, ListNode* pDeleted)  
2. {  
3.     if(pHead == NULL || pDeleted == NULL)  
4.         return NULL;  
5.   
6.     if(pDeleted->next != NULL) //不是最后一个结点  
7.     {  
8.         ListNode *pNext = pDeleted->next; //删除的其实是下一个结点  
9.         //下面两步是关键  
10.         pDeleted->key = pDeleted->next->key;  
11.         pDeleted->next = pDeleted->next->next;  
12.         delete pNext;  
13.         pNext = NULL;  
14.     }  
15.     else    
16.     {  
17.         if(pHead == pDeleted) //删除结点既是第一个结点也是最后一个结点  
18.         {  
19.             pHead = NULL;  
20.         }  
21.         else  
22.         {  
23.             ListNode *pNode = pHead;  
24.             while(pNode->next != pDeleted) //找删除结点的前驱  
25.                 pNode = pNode->next;  
26.             pNode->next = pDeleted->next;  
27.         }  
28.         delete pDeleted;  
29.         pDeleted = NULL;  
30.     }  
31.     return pHead;  
32. }  

    问题4：两个单向链表，找出它们的第一个公共结点。

    思路：（1）可以利用散列来做，根据第一个链表的地址，建立一张散列表，然后针对第二个链表的每一个结点，查询散列表，如果找到，那么这个结点就是第一个公共的结点。这种方法的时间复杂度为O(Len(h1)+Len(h2))，空间复杂度为O(Len(h1))。（2）何海涛给出的，非常巧妙，时间复杂度为O(Len(h1)+Len(h2))，空间复杂度为O(1)。一个重要的思想就是，如果两个链表等长，那么让它们同时向前移动，一定能同时到达第一个公共结点，能想到这一点，解法自然而然就有了。所给的两个链表不一定等长，只需遍历一下，分别求出链表的长度，然后将长链表先往前移动两者的长度之差，再同时向前。下面给出这两种方法的具体算法。

    参考代码:

[cpp]  view plain copy print ?

1. ListNode* FindFirstCommonNode_Solution1(ListNode *pHead1, ListNode *pHead2)  
2. {  
3.     set<ListNode *> addrSet;   //这里用集合代替散列  
4.   
5.     //将链表的结点地址放入集合中  
6.     ListNode *pNode = pHead1;  
7.     while(pNode != NULL)         
8.     {  
9.         addrSet.insert(pNode);  
10.         pNode = pNode->next;  
11.     }  
12.   
13.     //开始寻找  
14.     pNode = pHead2;  
15.     while(pNode != NULL)  
16.     {  
17.         if(addrSet.find(pNode) != addrSet.end())  
18.             break;  
19.         pNode = pNode->next;  
20.     }  
21.     return pNode;  
22. }  

[cpp]  view plain copy print ?

1. //求链表长度  
2. int LengthOfList(ListNode *pHead)  
3. {  
4.     int len = 0;  
5.     ListNode *pNode = pHead;  
6.     while(pNode != NULL)  
7.     {  
8.         len++;  
9.         pNode = pNode->next;  
10.     }  
11.     return len;  
12. }     
13.   
14. //用何海涛的方法  
15. ListNode* FindFirstCommonNode_Solution2(ListNode *pHead1, ListNode *pHead2)  
16. {  
17.     int len1 = LengthOfList(pHead1);  
18.     int len2 = LengthOfList(pHead2);  
19.     //确定长链表  
20.     int lenDiff = len1 - len2;  
21.     ListNode *pLong = pHead1;  
22.     ListNode *pShort = pHead2;  
23.     if(len1 < len2)  
24.     {  
25.         pLong = pHead2;  
26.         pShort = pHead1;  
27.         lenDiff = len2 - len1;  
28.     }  
29.     //调整长链表的长度  
30.     for(int i = 0; i < lenDiff; i++)  
31.         pLong = pLong->next;  
32.   
33.     ListNode *pNode = NULL;  
34.     while(pShort != NULL)  
35.     {  
36.         if(pShort == pLong)  //找到第一个共同结点  
37.         {  
38.             pNode = pShort;  
39.             break;  
40.         }  
41.         pShort = pShort->next;  
42.         pLong = pLong->next;  
43.     }  
44.     return pNode;  
45. }