快速排序（递归与非递归）详解（图示）

快速排序

快速排序：（平均性能最快）
1.在待排序数据中选取一个数据作为基准（选择第一个数据）
2.使用基准数据将剩余的数据分成两部分，左部分（不一定有序）都比基准小，//从后向前找比基准值小的数据
                                      右部分（不一定有序）都比基准大，从前往后找比基准值大的数据
  前两步封装成函数 OneQuick();一次快排
3.分别在对左部分(至少有两个数据时)和右部分(至少有两个数据时)数据进行快速排序（递归）
  快速排序的接口：Quick();参数：arr  start  end
  接受封装：QuickSort();参数：arr  len

特点：
数据越乱越有序。
数据越有序，效率越低。
快速排序如何优化：
1.如果数据个数较少，则直接调用直接插入排序或者冒泡
2.三数取中法：取最左端、中间和最右端的值，取这三个值中的中间值。
3.随机数
时间复杂度：O(n*logn)    最坏：O(n^2)
空间复杂度：O(logn)      最坏：O(n)
稳定性：不稳定

实现过程

具体实现

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stack>

using namespace std;

/*
快速排序：（平均性能最快）
    1.在待排序数据中选取一个数据作为基准（选择第一个数据）
    2.使用基准数据将剩余的数据分成两部分，左部分（不一定有序）都比基准小，//从后向前找比基准值小的数据
                                          右部分（不一定有序）都比基准大，从前往后找比基准值大的数据
      前两步封装成函数 OneQuick();一次快排
    3.分别在对左部分(至少有两个数据时)和右部分(至少有两个数据时)数据进行快速排序（递归）
      快速排序的接口：Quick();参数：arr  start  end
      接受封装：QuickSort();参数：arr  len

特点：
    数据越乱越有序。
    数据越有序，效率越低。
快速排序如何优化：
    1.如果数据个数较少，则直接调用直接插入排序或者冒泡
    2.三数取中法：取最左端、中间和最右端的值，取这三个值中的中间值。
    3.随机数
//递归的
时间复杂度：O(n*logn)    最坏：O(n^2)
空间复杂度：O(logn)      最坏：O(n)
稳定性：不稳定
*/

#define DATANUM 15

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

int IsOrder(int* arr, int length)
{
    for (int i = 0; i < length - 1; i++)
    {
        if (arr[i] > arr[i + 1])
        {
            return 0;
        }
    }
    return 1;
}

//优化2
void Three_Get_Mid(int* arr, int left, int right)
{
    int middle = (left + right) / 2;

    if (arr[left] > arr[middle])
    {
        int temp = arr[left];
        arr[left] = arr[middle];
        arr[middle] = temp;
    }
    if (arr[middle] > arr[right])
    {
        int temp = arr[middle];
        arr[middle] = arr[right];
        arr[right] = temp;
    }

    //arr[mid]为中间值

    if (arr[left] < arr[middle])
    {
        int temp = arr[left];
        arr[left] = arr[middle];
        arr[middle] = temp;
    }
}
void Quick_unrecur(int* arr, int start, int end)//O(nlog(n))
{
    stack<int> st;
    st.push(start);
    st.push(end);

    while (!st.empty())
    {
        int right = st.top();
        st.pop();
        int left = st.top();
        st.pop();
        //mid就是一次快排返回的基准位置，左(left...mid-1),右(mid+1...right)
        int mid = Partion(arr, left, right);
        if (mid - left > 1)
        {
            
            st.push(left);
            st.push(mid - 1);
        }
        if (right - mid > 1)
        {
            
            st.push(mid + 1);
            st.push(right);
        }
    }
}

//快速排序的一次划分（Partion）
int Partion(int* arr, int start, int end)//O(n)
{
//优化2
    //Three_Get_Mid(arr, start, end);
    int tmp = arr[start];//基准
    int left = start, right = end;
    while (left < right) //i==j要退出循环
    {
        while (left < right && arr[right] >= tmp)//从后向前找比基准值小的数据
        {
            right--;
        }
        if (arr[right] < tmp)
        {
            arr[left] = arr[right];
        }

        while (left < right && arr[left] <= tmp)//从前往后找比基准值大的数据
        {
            left++;
        }
        if (arr[left] > tmp)
        {
            arr[right] = arr[left]; 
        }
    }

    arr[left] = tmp;//基准应该放的位置
    return left;
}

void Quick_recur(int* arr, int start, int end)//O(log(n))
{
    int mid = Partion(arr, start, end);//一次划分

    //递归：O(log(n))
    if ((mid - start) > 1)//mid的左部分数据,左边的数据超过一个就需要排序
    {
        Quick_recur(arr, start, mid - 1);
    }
    if ((end - mid) > 1)//mid的右部分数据
    {
        Quick_recur(arr, mid + 1, end);
    }
}
void Quick(int* arr, int start, int end)//O(log(n))
{
    int mid = Partion(arr, start, end);//一次划分

    //递归：O(log(n))
    
}
void QuickSort(int* arr, int len)//O(nlog(n))
{
//优化1
    if (len < 100)
    {
        //调用快速排序或者插入排序
    }
    Quick_recur(arr, 0, len - 1);
}

int main()
{
    int arr[DATANUM];
    for (int i = 0; i < DATANUM; i++)
    {
        arr[i] = rand() % 100;
    }
    printf("Before QuickSort:");
    Show(arr, DATANUM);

    QuickSort(arr, DATANUM);
    if (IsOrder(arr, DATANUM))
    {
        printf("After QuickSort:");
        Show(arr, DATANUM);
    }
    else
    {
        printf("QuickSort Failed\n");
    }

    return 0;
}