Sort_List@LeetCode

1.规定了时间复杂度o(nlogn):采用归并排序，在归并过程：采用分合思想，递归将链表分为两段之后再将merge

分两段方法使用 fast-slow法，用两个指针P1，P2，p1指针每一次走两步，p2指针每一次走一步；当P1指针走到末尾时候，P2指针刚好在中间位置，直到将N序列分成最小子序列单个链表

merge方法：单个链表对合并成有序父链表，比较表头的值，一个P指针指向表头较小值，p指针向后移动，合并至连接到Temp连接表中

1. 采用fast-slow过程中注意 fast=head slow=head

2.在归并merge算法中 使用倆个指针 headTemp指针指向其链表首地址，Rear指针遍历之后节点（将其他位置上的节点连接已有地址上来）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        /*拆分最小单子序列 与 单子序列进行合并*/
        
        if(head==NULL || head->next==NULL) return head;
        
        /*定义fast-slow将链表进行分割*/
       ListNode *slow=head,*fast=head;
        //找的中间点从中分为right 与 left
        while(fast->next && fast->next->next)
          {
                slow=slow->next;
                fast=fast->next->next;
          }
        
        ListNode *H1=head,*H2=slow->next;
        slow->next=NULL;//将分割成俩块
        
        H1=sortList(H1);H2=sortList(H2);
        
        return merge(H1,H2);
        
    }
    
    ListNode *merge(ListNode * Left, ListNode * right)
    
    {
        
        ListNode *headTemp ;/*使用两个指针一个记录开始地址，另外一个地址所有后续节点*/
        /*必须headTemp指针指向大的值作为开始*/
        if(Left->val < right->val)
            {
                headTemp=Left;
                Left=Left->next;
            }
        else
           {
                headTemp=right;
                right=right->next;
           }
            
        ListNode *p=headTemp;
        while(Left!=NULL && right!=NULL)
          {
            
                if(Left->val<right->val)
                     {
                        p->next=Left;
                        p=p->next;//往后移动指向下一个指针,P失去前一个节点但是
                                    //headTemp记录前一个节点p=p->next，将其他地址链接到当前地址后面
                        Left=Left->next;
                     }
                    else
                     {
                     
                       p->next=right;
                        p=p->next;//往后移动指向下一个指针
                        right=right->next;
                 }
          }
        
        if(Left==NULL)
            {
            p->next=right;
            }
        if(right==NULL)
            {
            p->next=Left;
        }
        
        return headTemp;
    }
   
};

 此算法用了测试 如何建立链表：建立链表中 new 开辟地址，在输入过程中新的链表链接到此上，最后将开始无用链表进行删除

/*从尾部向头部打印*/
#include<iostream>
#include<stack>
using namespace std;
struct ListNode
{
    int m_nKey;
    ListNode *m_pNext;
};

class Solution
{
public:
    void PrintListReverse(ListNode * pHead)
    {
        /*使用堆栈--后进先出特性*/
        std::stack<ListNode *> nodes;
        ListNode *PNode=pHead;

        while(PNode!=NULL )
        {
            nodes.push(PNode);    
            PNode=PNode->m_pNext;
        }

        while(!nodes.empty())
        {
            PNode=nodes.top();
            std::cout<<PNode->m_nKey<<" ";
            nodes.pop();
        }
    }

};

int main()
{
    ListNode *List=new ListNode();List->m_pNext=NULL;

    ListNode *pList=List; int m_value;
    
    while(true)
    {
        cin>>m_value;
        if(m_value==-1)
        {
            
            pList=NULL;
            break;

        }
        /*开辟新的链表节点，将新的链表节点连接到已有节点上，最后将Head无用节点删除*/
        ListNode *Rear=new ListNode;
        Rear->m_nKey=m_value; Rear->m_pNext=NULL;
        pList->m_pNext=Rear;
        /*pList指向此新节点*/
        pList=pList->m_pNext;
    }
    /*开始时候多了一个节点*/
    List=List->m_pNext;

    Solution S;
    S.PrintListReverse(List);
    return 0;
}

 快速排序 链表方式

单向链表采用快速排序:不同于数组的快速排序，单向链表没有前驱指针，但是其还可以借助 快速排序的思想：两个指针prev1=phead，prev2=prev1->next, 两者指针从前遍历到尾，prev2指针先于prev1，当遇到小于基数X值，swap交换prev2->val 和 p->next->val（这样保证p往前移动，直到遇到支点返回)

/*链表快速排序*/
#include<iostream>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    
};

ListNode *GetPartion(ListNode *Head,ListNode*end)
{
    ListNode *prev1=Head;
    ListNode * prev2=prev1->next;
    int Key=Head->val;
    /*利用俩个指针从前往后遍历，最后找到一个支点，支点之前小于基数，支点之后大于基数*/
    while(prev2!=NULL && prev2!=end)
    {
        if(prev2->val<Key )
        {
            prev1=prev1->next;
            swap(prev1->val,prev2->val);
        }
        prev2=prev2->next;
    }

    /*prev1就是支点位置*/
    swap(prev1->val,Head->val);
    return prev1;
}
void QuickSort(ListNode *pHead,ListNode *pEnd)
{
    /*使用两个不同指针从前往后遍历*/
    if(pHead==NULL || pHead->next==NULL)
        return;
    if(pHead!=pEnd)
    {
        ListNode * partion=GetPartion(pHead,pEnd);
        QuickSort(pHead,partion);
        /*注意在这里必须要partion->next,不然出现明显的死循环问题*/
        QuickSort(partion->next,pEnd);
    }

}
void printQuickSort(ListNode *head)
{
    if(head==NULL)
    {    cout<<"输入空节点"<<endl;
    

        return ;
    }

    ListNode *pHead=head;
    
    while(pHead!=NULL)
    {
        cout<<pHead->val<<" ";
        pHead=pHead->next;
    }
}
int main()
{
    ListNode *List=new ListNode();List->next=NULL;

    ListNode *pList=List; int m_value;
    while(true)
    {
        cin>>m_value;
        if(m_value==-1)
        {
            
            pList=NULL;
            break;

        }
        /*开辟新的链表节点，将新的链表节点连接到已有节点上，最后将Head无用节点删除*/
        ListNode *Rear=new ListNode;
        Rear->val=m_value; Rear->next=NULL;
        pList->next=Rear;
        /*pList指向此新节点*/
        pList=pList->next;
    }
    /*删除开始时候多了一个节点，只有先有地址链表才能够运行*/
    List=List->next;
    QuickSort(List,NULL);
    printQuickSort(List);
    return 0;
}

输入空节点时候，程序并没有崩溃