快速排序（数组和链表版本）

快速排序：

如果在数组已经是升序降序的情况下，可能会出现n^2 的复杂度，可在预先处理

枢纽元的选取也有多种方式

第一个区间第一个数字

区间最后一个数字

区间第一个数字，最后一个数字，中间位置的数字，这三个数的中位数为做枢纽元，一般来说 第三种会会使快排的效率好些

时间复杂度：O(NlogN) 最坏情况下O(N＊N)

空间复杂度：O(logN)

#include <stdio.h>
void qsort(int* a, int le, int ri){
    if(le >= ri)
        return;
    int i = le, j = ri;
    int p = a[le];
    while(i < j){
        
        while(a[j] > p && j > i )
            j--;
        if(i < j){
            a[i] = a[j];
            i++;
        }
        while(a[i] < p && i < j)
            i++;
        if(i < j){
            a[j] = a[i];
            j--;
        }
            
    }
    a[i] = p;
    qsort(a,le,i-1);
    qsort(a,i+1, ri);
}




int main() {
    int a[10] = {1,6,2,9,5,2,4,8,5,7};
    qsort(a,0,9);
    int i=0;
    for(i=0; i<10; i++){
        printf("%d\n", a[i]);
    }
    return 0;
}

//链表般的快速排序

void qSort(node * head,node * tail){
    if(head == NULL || head == tail)
        return;
    node* le = head, * ri = tail;
    int p = head->val;
    while(le != ri){
        while(le != ri && ri->val > p)
            ri = ri->pre;
        if(le != ri){
            le->val = ri->val;
            le = le->next;
        }
        while(le != ri && le->val < p)
            le = le->next;
        if(le != ri){
            ri->val = le->val;
            ri = ri->pre;
        }
    }
    le->val = p;
    if(head != le)
        qSort(head,le->pre);
    if(le != tail)
        qSort(le->next,tail);
    
}