单链表排序

这部分实现的排序方法是冒泡排序和快速排序。

冒泡排序的基本思想就是对于给定的n个元素，从第一个元素开始，依次对相邻的两个元素进行比较，当前面的元素大于后面的元素时，交换其位置，进行一轮比较和换位后，n个元素中最大的数将位于第n位，然后对前（n-1）个元素进行第二轮比较，重复该过程，直到进行比较的元素只剩下一个。

单链表的快速排序和数组的快速排序在基本细想上是一致的，以从小到大来排序单链表为例，都是选择一个支点，然后把小于支点的元素放到左边，把大于支点的元素放到右边。但是，由于单链表不能像数组那样随机存储，和数组的快排序相比较，还是有一些需要注意的细节：

1. 支点的选取，由于不能随机访问第K个元素，因此每次选择支点时可以取待排序那部分链表的头指针。

2. 遍历链表方式，由于不能从单链表的末尾向前遍历，因此使用两个指针分别向前向后遍历的策略实效，可以可以采用一趟遍历的方式将较小的元素放到单链表的左边。具体方法为：

    1)定义两个指针pSlow, pFast,其中pSlow指单链表头结点，pFast指向单链表头结点的下一个结点;

    2)使用pFast遍历单链表，每遇到一个比支点小的元素，就和pSlow进行数据交换,然后令pSlow=pSlow->next。

3. 交换数据方式，直接交换链表数据指针指向的部分，不必交换链表节点本身。

快排这里还是写了两个函数，Partition这个函数，返回的支点结点的前一个位置。

#include <iostream>
#include <algorithm>
#include "string.h"
#include "stdio.h"
#include <vector>
#include <deque>
#include<stack>
using namespace std;

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class List{
public:

    ListNode* CreatList(int* arr,int len)
    {
        int val;
        ListNode* pHead = new ListNode(arr[0]);
        ListNode* pCurrent=NULL;
        ListNode* rear = pHead;
        int count = 1;
        while(count<len)
        {
            ListNode* pCurrent = new ListNode(arr[count]);
            rear->next = pCurrent;
            rear = pCurrent;
            count++;
        }
        rear->next = NULL;
        return pHead;
    }
    void ShowList(ListNode* pHead)
    {
       while(pHead)
       {
           cout<<pHead->val<<" ";
           pHead = pHead->next;
       }
       cout<<endl;
    }
　　//得到链表中最后一个结点
    ListNode* GetLastNode(ListNode* pHead)
    {
        ListNode* pNode = pHead;
        while(pNode->next!=NULL)
        {
            pNode=pNode->next;
        }
        return pNode;
    }
};
class Sort{
public:
　　//冒泡排序
    ListNode* BubbleSortList(ListNode* pHead)
    {
        ListNode* pNode1 = pHead;
        ListNode* pNode2 = pHead;
        if(pHead == NULL)
            return NULL;
        for(;pNode1->next!=NULL;pNode1=pNode1->next)
        {
            for(pNode2=pHead;pNode2->next!=NULL;pNode2=pNode2->next)
            {
                if(pNode2->val>pNode2->next->val)
                {
                    int temp = pNode2->val;
                    pNode2->val = pNode2->next->val;
                    pNode2->next->val = temp;
                }
            }
        }
        return pHead;
    }
　　//快速排序
    void QuickSortList(ListNode* pHead,ListNode* pEnd)
    {
        if(pHead != pEnd)
        {
            ListNode* part = Partition(pHead,pEnd);
            QuickSortList(pHead,part);
            QuickSortList(part->next,pEnd);

        }
    }
    ListNode* Partition(ListNode* pBegin,ListNode* pEnd)
    {

        int key = pBegin->val;
        ListNode* pSlow = pBegin;
        ListNode* pFast = pSlow->next;
        ListNode* temp = pBegin;

        while(pFast!=NULL&&pFast!=pEnd->next)
        {
            if(pFast->val <key)
            {
               temp = pSlow;                
　　　　　　　　　pSlow = pSlow->next;

                swap(pSlow->val,pFast->val);
            }

            pFast = pFast->next;
        }
        swap(pSlow->val,pBegin->val);
        return temp;//返回的结点为支点节点的前一个结点    
　　}
};
int main()
{
    int array[]={3,4,5,1,2,8,7};
    List list;
    Sort sort;
    ListNode* pHead1 = list.CreatList(array,sizeof(array)/sizeof(array[0]));
    ListNode* pHead2 = list.CreatList(array,sizeof(array)/sizeof(array[0]));
    list.ShowList(pHead1);
    sort.BubbleSortList(pHead1);
    list.ShowList(pHead1);
    ListNode* pEnd = list.GetLastNode(pHead2);
    //cout<<pEnd->val<<endl;
    sort.QuickSortList(pHead2,pEnd);
    list.ShowList(pHead2);
    return 0;
}