单链表的快速排序

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

当然,怎么值交换?

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

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

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

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

    struct Node{  
        int key;  
        Node* next;  
    }; 

 

 

    struct Node   
    {  
        int key;  
        Node* next;  
        Node(int nKey, Node* pNext)  
            : key(nKey)  
            , next(pNext)  
        {}  
    };  
      
      
    Node* GetPartion(Node* pBegin, Node* pEnd)  
    {  
        int key = pBegin->key;  
        Node* p = pBegin;  
        Node* q = p->next;  
      
        while(q != pEnd)  
        {  
            if(q->key < key)  
            {  
                p = p->next;  
                swap(p->key,q->key);  
            }  
      
            q = q->next;  
        }  
        swap(p->key,pBegin->key);  
        return p;  
    }  
      
    void QuickSort(Node* pBeign, Node* pEnd)  
    {  
        if(pBeign != pEnd)  
        {  
            Node* partion = GetPartion(pBeign,pEnd);  
            QuickSort(pBeign,partion);  
            QuickSort(partion->next,pEnd);  
        }  
    } 


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

 

 

原文地址:http://blog.csdn.net/otuhacker/article/details/10366563

posted @ 2015-11-21 00:36  aprogrammer  阅读(365)  评论(0编辑  收藏  举报