快速排序的递归非递归

快速排序：
即一趟快速排序的过程，返回基准。基准：平分数据段
时间复杂度：好情况（无序的数据）：O（nlog2n） 坏（有序）：O（n2）
空间复杂度：O（log2n）
算法稳定性：不稳定
原理：采用分治思想，在待排序的序列中选取一个值作为一个基准值，按照这个基准值得大小将这个序列划分成两个子序列，基准值会在这两个子序列的中间，一边是比基准小的，另一边就是比基准大的。这样快速排序第一次排完，我们选取的这个基准值就会出现在它该出现的位置上。这就是快速排序的单趟算法，也就是完成了一次快速排序。然后再对这两个子序列按照同样的方法进行排序，直到只剩下一个元素或者没有元素的时候就停止，这时候所有的元素都出现在了该出现的位置上。
例：一趟排序（以6为基准）
0 1 2 3 4 5 arr[]:
6 2 7 3 8 9 low=0 high=5 tmp=6
6 2 7 3 8 9 low=0 high=3 tmp=6 arr[high]=3 < tmp=6
3 2 7 6 8 9 low=0 high=3 tmp=6 arr[low]=arr[high]3
3 2 7 6 8 9 low=2 high=3 tmp=6 arr[low]=7 > tmp=6
3 2 6 7 8 9 low=2 high=3 tmp=6 arr[high]=arr[low]7 6的位置已确定

//递归
int  Partion(int *arr, int low, int high)
{   
    int tmp = arr[low];
    while (low<high)
    {
        while (low < high && arr[high] >= tmp)
        {
            high--;
        }
        if (low >= high)
        {
            break;
        }
        else
        {
            arr[low] = arr[high];
        }
        while (low<high && arr[low] <= tmp)
        {
            low++;
        }
        if (low >= high)
        {
            break;
        }
        else
        {
            arr[high] = arr[low];
        }
    }
    arr[low] = tmp;
    return low;//par基准
}

void Quick(int *arr, int start, int end)
{
    int par = Partion(arr, start, end);
    if (par>start + 1)//如果左边有两个数据以上
    {
        Quick(arr, start, par - 1);
    }
    if (par<end - 1)//如果右边有两个数据以上
    {
        Quick(arr, par + 1, end);
    }
}
void Quick_Sort(int  *arr, int len)
{
    Quick(arr, 0, len - 1);
}

//非递归
void Quick_Sort1(int  *arr, int len)
{
    //1.申请一块内存当栈
    //2.进行一次快速排序，找到基准
    //3.把左边 右边的数对进行入栈
    //4.取出数据进行一趟快速排序
    //5.top>0
    int *stack = (int *)malloc(sizeof(int) * len);//定义栈的大小
    assert(stack != NULL);
    int top = 0;
    int low = 0;
    int high = len - 1;
    int par = Partion(arr, low, high);
    if (par>low + 1)//左边有两个数据以上数时  入栈
    {
        stack[top++] = low;
        stack[top++] = par - 1;
    }
    if (par<high - 1)//右边左边有两个数据以上数时  入栈
    {
        stack[top++] = par + 1;
        stack[top++] = high;
    }
    while (top>0)//出栈  栈不空，需要取两个数据出来排序
    {
        high = stack[--top];
        low = stack[--top];
        par = Partion(arr, low, high);
        if (par>low + 1)
        {
            stack[top++] = low;
            stack[top++] = par - 1;
        }
        if (par<high - 1)
        {
            stack[top++] = par + 1;
            stack[top++] = high;
        }
    }
    free(stack);
    stack = NULL;
}

测试：

void Show(int *arr, int len)
{
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main()
{
    int arr[] = { 5,1,8,42,12,65,24,0 };
    int len = sizeof(arr) / sizeof(arr[0]);
    //Quick_Sort(arr, len);
    Quick_Sort1(arr, len);
    Show(arr, len);
    return 0;
}