快速排序-完整实现-快排-递归-非递归

一、思路

1、采用递归方法，然后采用两个指针移动的方法
2、快速排序思路：
第一步：选定一个初始值（一般为第一个）；
第二步：从右边开始找起，找到第一个比初始值低的值，将两个交换
第三步：从左边开始找起，找到第一个比初始值高的值，将两者交换
第四步：当两个指针相遇的时候，第一轮快排完成
第五步：递归，传入数组，开始的两个指针

二、代码

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int QuSort(int arr[], int first, int last)
{
    //当传入进来的不需要排序时就返回
    if (first >= last)
    {
        return 0;
    }
    //定义两个变量作为移动指针
    int l = first;
    int r = last;
    //刚开始记录初始值
    int x = arr[l];
    //当两个指针相遇时就退出
    while (l < r)
    {
        //第一步，当右边的大于等于初始值时，右指针--
        while (arr[r] >= x && l < r)
        {
            r--;
        }
        //判断是否右边是否有一个值小于初始值
        if (arr[r] < x && l < r)
        {
            //互换，并将左指针加1
            arr[l++] = arr[r];
            arr[r] = x;
        }

        while (arr[l] <= x && l < r)
        {
            l++;
        }
        //判断是否左边是否有一个值小于初始值
        if (arr[l] > x && l < r)
        {
            //互换，并将右指针减1
            arr[r--] = arr[l];
            arr[l] = x;
        }
    }
    QuSort(arr, first, l - 1);
    QuSort(arr, l + 1, last);
    return 0;
}

int main()
{

    int arr[] = {1, 4, 2, 6, 9, 7, 8, 8, 6, 8, 3};
    QuSort(arr, 0, sizeof(arr) / sizeof(arr[0]) - 1);
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
    {
        cout << arr[i];
    }
    return 0;
}

三、非递归实现

void QSort(vector<int> &res, int left, int right)
{
    //判断条件是否符合
    if (left >= right)
    {
        return;
    }
    //建立栈储存头尾节点
    stack<int> st;
    //添加头尾节点入栈
    st.push(left);
    st.push(right);

    while (!st.empty())
    {
        int last = st.top();
        st.pop();
        int first = st.top();
        st.pop();
        int l = first;
        int r = last;
        int temp = res[first];
        //正常快排程序
        while (l < r)
        {
            while (l < r && res[r] >= temp)
            {
                r--;
            }
            if (l < r)
            {
                res[l++] = res[r];
                res[r] = temp;
            }
            while (l < r && res[l] <= temp)
            {
                l++;
            }
            if (l < r)
            {
                res[r--] = res[l];
                res[l] = temp;
            }
        }
        //判断数据是否大于1个，大于就添加头尾节点入栈
        if (l - 1 > first)
        {
            st.push(first);
            st.push(l - 1);
        }
        if (last > l + 1)
        {
            st.push(l + 1);
            st.push(last);
        }
    }
}

int main()
{
    vector<int> res{2, 8, 5, 7, 1, 6, 3};
    QSort(res, 0, res.size() - 1);
    return 0;
}