快速排序

快排做为一个时间复杂度系数比较好的排序方法用的比较多，基本原理为：

每次把其中一个数放在正确的位置，然后递归的比较另外两段逻辑上独立的数据；

那类比冒泡法也是每次把一个数据放在正确的位置上，有什么区别呢？

快排把一个数据放到正确的位置上，会使原来的数据一分为二，那么分开的数据只会跟它所在那块数据来比较，总的比较次数少了，其实就是乘以2，和n平方除以2的区别，两部分只和各自逻辑段内的数据比较，时间复杂度当然低了。

冒泡法只是从头开始，每次拿到最小或者最大的数据，但是每次比较的次数还是剩余的所有个数，只是依次减少，最后还是n平方除以2.

快速排序是不稳定的排序，在每个回合排序的时候牵扯到数据交换，且会交叉交换导致跟原始数据顺序不一致

附上实现代码：

#include "stdio.h"
void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

int partion(int start,int end,int* array)
{
    int i = start -1;
    int j = start;
    int x = array[end];
    for(;j<end;j++)
        if(array[j]<x)
        {
            i++;
            swap(&(array[j]),&(array[i]));
        }
      swap(&(array[i+1]),&(array[end]));
      return i+1;
}

void quick_sort(int start,int end,int* array)
{
    if(start<end)
    {
        int position = partion(start,end, array);
        quick_sort(start,position-1,array);
        quick_sort(position+1,end,array);
    }
}

void display(int* array,int len)
{
    int i = 0;
    for(;i<len;i++)
    {
        printf("%d ",array[i]);

    }
    printf("\n");
}

int main()
{
    int array[10] = {1,32,4,65,83,2,1,0,9,0};
    display(array,10);
    quick_sort(0,9,array);
    display(array,10);
    return 0;
}

实现思路：

i代表了当前已经确定了的比x小的数据在数组的位置，只所以一开始是比最小索引小1，是因为极有可能出现x是最小的一个，那么swap是需要交换第一个值和最后一个，总之这个i之所以这样设置，是为了程序书写的简洁完整统一而做的调整。

j代表了当前比x大的数据在待排序数组里面的位置；
    

还有一种思路是减少交换的次数，两头轮着来赋值。

实现方法：

#include "stdio.h"

int  partion(int start,int end,int *array)
{
    int left_flag = start;
    int right_flag = end ;
    if(start >= end)
        return ;

    int X = array[end];
    int position = end;

    while(left_flag < right_flag)
    {
        while(left_flag < right_flag) //begin from left
        {
            if( array[left_flag] > X)
            {
                array[position] = array[left_flag];
                position = left_flag;
                break;
            }
            else
            {
                if(left_flag < right_flag)
                    ++left_flag;
            }
        }
        while(left_flag < right_flag) //begin from right
        {
            if(array[right_flag]<X)
            {
                array[position] = array[right_flag];
                position = right_flag;
                break;
            }
            else
            {
                if( right_flag > left_flag )

                     right_flag=right_flag-1;
            }
        }
    }

    array[right_flag] = X;
    return right_flag;

}
void quick_sort(int start,int end,int *array)
{
    if(start<end)
    {
        int middle = partion(start,end,array);
        quick_sort(start,middle-1,array);
        quick_sort(middle+1,end,array);
    }
}
int main()
{
    int array[10] = {3,4,1,12,4,6,1,10,8,10};
    int ret = 0;
    int start = 0, end = 9;
    int i =0;
    quick_sort(start,end,array);
    printf("sort over\n");
    for(;i<10;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");
    return 0;
}