交换排序——快排/冒泡

快速排序：
平均时间复杂度:O(NlogN) ， 最坏时间复杂度: O（N^2） 不稳定
快速排序思想：
1、在待排序列中找一个基准值（默认选择最后一个元素）
2、然后将该基准值放置在合适的位置，
3、使得基准值之前的元素都小于等于基准值，基准值之后的元素都大于等于基准值。

然后再对基准值之前的序列使用上述方法进行排序寻找基准值的位置
对基准值之后的序列也使用上述方法，进行排序寻找基准值的位置，是一个递归的过程

实现方法分为两种，一种是交换法 一种是挖坑法
交换法

定义left,和right分别为首尾元素下标
left先从前往后遍历找到一个大于基准值的元素，然后停下来
接着right从后往前遍历找到一个小于基准值的元素，然后停下来
交换left,right下标所指向的元素值，
left继续向后遍历，right继续向前遍历当Left==right时
交换left指向元素和基准值 当待排序序列元素个数为1则直接返回

//交换函数
int Pattern(int arr[], int left, int right)
{
    if(right-left<=1)
        return left;
    int left_index=0;
    int right_index=right-1;
    int basic_index=right-1;

    while(left_index<right_index)
    {
        while(left_index<right_index&&arr[left_index]<arr[basic_index])
        {
            left_index++;
        }
        while(left_index<right_index&&arr[right_index]>arr[basic_index])
        {
            right_index--;
        }
        Swap(&arr[left_index],&arr[right_index]);
    }
    Swap(&arr[left_index],&arr[basic_index]);
    return left_index;
}

//递归函数
void  _Quick(int arr[],int left, int right)
{
    if(arr==NULL||right-left<=1)
        return ;
    int mid=Pattern(arr,left,right);
    //[0,right)
    _QUickSort(arr,left,mid);
    _QUickSort(arr,mid+1,right);
}

//函数主体
void quick(int arr[],int size)
{
    if(arr==NULL||size<=1)
        return ;
    int left=0;
    int right=size;
    _Quick(arr,left,right);
}

冒泡排序
时间复杂度O(N^2) 稳定
冒泡排序的思想是一轮一轮的比较：

升序排序：将每一轮排序中最大的值放在最高位，次高位（从前往后冒泡），或者在每一轮排序中最小的值方在最低位，次低位。

void BubleSort(int arr[], int size,Compare cmp)
{
    if(arr==NULL||size<=1)
        return ;
    int i=0;
    for(i=0;i<size-1;i++) //控制遍历的轮数
        for(int j=0;j<size-1-i;j++) //控制每一轮比较的次数
            if(cmp(arr[j],arr[j+1])==1) 
                Swap(&arr[j],&arr[j+1]);
}