单链表快速排序

  单链表的特点是：单向。设头结点位head，则最后一个节点的next指向NULL。如果只知道头结点head，请问怎么将该链表排序？

               设结点结构为

[cpp] view plaincopy

1. struct Node{  
2.     int key;  
3.     Node* next;  
4. };  

          那么一般人见到这种题目，立马就会想到指针交换。是的，大家被指针交换的题目做多了，形成思维定势了。对于这道题，我们完全可以利用值交换来达到排序的目的。

当然，怎么值交换？

         很多人得第一想法就是选择排序，这个木有问题，不过它的复杂度为O(n^2)；有木有更好一点的方法呢？归并，不错，归并确实能将复杂度降到O(nlogn)不过，它是是链表交换的形式，我们这里提到的是要用值交换的形式。还有别的方法吗？对了，快排！

        你可能回诧异，怎么会是快排？快排不是需要一个指针指向头，一个指针指向尾，然后两个指针相向运动并按一定规律交换值，最后找到一个支点使得支点左边小于支点，支点右边大于支点吗（这句话很长，累死俺了）？是滴，木有错，不过问题出来了。如果是这样的话，对于单链表我们没有前驱指针，怎么能使得后面的那个指针往前移动呢？所以这种快排思路行不通滴，如果我们能使两个指针都往next方向移动并且能找到支点那就好了。怎么做呢？

        接下来我们使用快排的另一种思路来解答。我们只需要两个指针p和q，这两个指针均往next方向移动，移动的过程中保持p之前的key都小于选定的key，p和q之间的key都大于选定的key，那么当q走到末尾的时候便完成了一次支点的寻找。如下图所示：

           既然两个指针都是从前往后遍历，那么链表值进行交换就简单了。找到支点后，支点左边和支点右边进行子问题递归，就回到快排原来的思路上去了。代码如下：

[cpp] view plaincopy

1. struct Node   
2. {  
3.     int key;  
4.     Node* next;  
5.     Node(int nKey, Node* pNext)  
6.         : key(nKey)  
7.         , next(pNext)  
8.     {}  
9. };  
10.   
11.   
12. Node* GetPartion(Node* pBegin, Node* pEnd)  
13. {  
14.     int key = pBegin->key;  
15.     Node* p = pBegin;  
16.     Node* q = p->next;  
17.   
18.     while(q != pEnd)  
19.     {  
20.         if(q->key < key)  
21.         {  
22.             p = p->next;  
23.             swap(p->key,q->key);  
24.         }  
25.   
26.         q = q->next;  
27.     }  
28.     swap(p->key,pBegin->key);  
29.     return p;  
30. }  
31.   
32. void QuickSort(Node* pBeign, Node* pEnd)  
33. {  
34.     if(pBeign != pEnd)  
35.     {  
36.         Node* partion = GetPartion(pBeign,pEnd);  
37.         QuickSort(pBeign,partion);  
38.         QuickSort(partion->next,pEnd);  
39.     }  
40. }  

使用时只需调用QuickSort(pHead,NULL)即可！