单链表快排

在说链表快排的时候，我们先看普通的快排的代码

void QuickSort(vector<int> &num, int left, int right)
{
    if(left>=right)
    {
        return ;
    }
    int key=num[left];
    int i=left;
    int j=right;
    while(i<j)
    {
        while(i<j&&num[j]>key)
        {
            j--;
        }
        num[i]=num[j];
        while(i<j&&num[i]<key)
        {
            i++;
        }
        num[j]=num[i];
    }
    num[i]=key;
    QuickSort(num, left, i-1);
    QuickSort(num, i+1, right);

}

对于数组快排，我们需要两个指针(这里是下标)，分别指向数组中某段的头(i)和尾(j)，然后从尾端开始找，找到比key值小的值，然后让num[i]=num[j], 然后从头部开始遍历，找到比key值大的值，让num[j]=num[i], 当i>=j的时候，跳出循环体，然后继续分段([left,i-1]和[i+1,right])执行快排函数。

而对于单向链表来说，链表节点定义如下:

struct ListNode{
    int val;
    ListNode *next;
    ListNode(int tmp):val(tmp),next(NULL){}
};

因为对于节点来说，无法向前进行遍历，所以只能从头部往尾端遍历，我们同样的也是使用那个指针，不同的是都是从头部开始往后遍历，p指向链表头，q指向链表头的下一个节点，保证p到q之间一定是大于key值，而head到p之间一定是小于q值即可，具体代码如下：

ListNode* list_partition(ListNode *head, ListNode *tail)
{
    int key=head->val;
    ListNode *p=head;
    ListNode *q=head->next;
    while(q!=tail)
    {
        if(q->val<key)
        {
            p=p->next;
            swap(p->val,q->val);
        }
        q=q->next;
    }
    swap(p->val,head->val);
    return p;
}

全部代码如下

//
//  main.cpp
//  Quick_Sort
//
//  Created by wb on 2018/4/10.
//  Copyright © 2018年 wb. All rights reserved.
//

#include <iostream>
#include <vector>

using namespace std;
//数组快排
void QuickSort(vector<int> &num, int left, int right)
{
    if(left>=right)
    {
        return ;
    }
    int key=num[left];
    int i=left;
    int j=right;
    while(i<j)
    {
        while(i<j&&num[j]>key)
        {
            j--;
        }
        num[i]=num[j];
        while(i<j&&num[i]<key)
        {
            i++;
        }
        num[j]=num[i];
    }
    num[i]=key;
    QuickSort(num, left, i-1);
    QuickSort(num, i+1, right);

}

//链表快排
struct ListNode{
    int val;
    ListNode *next;
    ListNode(int tmp):val(tmp),next(NULL){}
};

/*
 保证p--q之间的值一定是大于key的，
 保证head-p之间的值一定是小于key的。
 */
ListNode* list_partition(ListNode *head, ListNode *tail)
{
    int key=head->val;
    ListNode *p=head;
    ListNode *q=head->next;
    while(q!=tail)
    {
        if(q->val<key)
        {
            p=p->next;
            swap(p->val,q->val);
        }
        q=q->next;
    }
    swap(p->val,head->val);
    return p;
}

void List_Quick(ListNode *head,ListNode *tail)
{
    if(head!=tail)
    {
        ListNode *p=list_partition(head, tail);
        List_Quick(head, p);
        List_Quick(p->next, tail);
    }
}

ListNode * generate_ListNode()
{
    ListNode * head=new ListNode(4);
    ListNode *help=head;
    help->next=new ListNode(1);
    help=help->next;
    help->next=new ListNode(6);
    help=help->next;
    help->next=new ListNode(2);
    help=help->next;
    help->next=new ListNode(3);
    help=help->next;
    help->next=new ListNode(7);
    help=help->next;
    help->next=new ListNode(5);
    help=help->next;

    return head;
}


int main(int argc, const char * argv[]) {
    vector<int> arr{4,1,6,2,3,7,5};
    QuickSort(arr, 0, arr.size()-1);
    for(int i=0;i<arr.size();i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    ListNode *head=generate_ListNode();
    List_Quick(head, NULL);
    while(head)
    {
        cout<<head->val<<" ";
        head=head->next;
    }
    cout<<endl;
}