c++实现非递归的快速排序

代码说明

代码是我亲自码的，调试通过的，代码中有算法思想和详细的注释，一目了然。

项目已经上传到我的github：https://github.com/yisun03/sort

递归实现见我的另一篇blog:  https://blog.csdn.net/weixin_39408343/article/details/107086104

项目中还有另外得九种排序算法的c++实现代码以及其思想。

十种排序算法清代如下(附我的blog链接)：

1   选择排序：https://blog.csdn.net/weixin_39408343/article/details/107063290              
2   插入排序：https://blog.csdn.net/weixin_39408343/article/details/107070155                   
3   冒泡排序：https://blog.csdn.net/weixin_39408343/article/details/107070658              
4   希尔排序：https://blog.csdn.net/weixin_39408343/article/details/107071758
5.1 归并排序递归实现：https://blog.csdn.net/weixin_39408343/article/details/107083607
5.2 归并排序非递归实现：https://blog.csdn.net/weixin_39408343/article/details/107084688
6.1 快速排序递归实现：https://blog.csdn.net/weixin_39408343/article/details/107086104
6.2 快速排序非递归实现：https://blog.csdn.net/weixin_39408343/article/details/107087359
7   堆排序：https://blog.csdn.net/weixin_39408343/article/details/107092851
8   计数排序：https://blog.csdn.net/weixin_39408343/article/details/107094547
9   桶排序：https://blog.csdn.net/weixin_39408343/article/details/107113821
10  基数排序：https://blog.csdn.net/weixin_39408343/article/details/107115403

术语说明

1、稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序。

2、非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。

3、原地排序：原地排序指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序。

4、非原地排序：需要利用额外的数组来辅助排序。

5、时间复杂度：一个算法执行所消耗的时间。

6、空间复杂度：运行完一个算法所需的内存大小。

性能分析

时间复杂度：O(n*log(n))

空间复杂度：O(log(n))

非稳定的原地排序
 

int sort::partition(std::vector<int> &data, int left, int right)
  {
    // 找到中轴数的正确位置,同时将序列划分为两部分.
    // 中轴数有很多种取法,我们这里采用《算法导论》里的选取方法,即取序列最后一个元素.
    int key = data.at(right);
    // 此处设置两个索引i和j,区间[left,i]为小于中轴数的序列,
    // 区间[j,right-1]为大于中轴数的序列.
    int i = left - 1;
    for(int j = left; j < right; j++)
    {
      if(data.at(j) <= key)
      {
        // 大于中轴数的元素让它继续待在[j,right-1]区间什么也不做;
        // 小于中轴数的元素全部从[j,right-1]区间放到[left,i]区间去.
        ++i;
        int temp = data.at(i);
        data.at(i) = data.at(j);
        data.at(j) = temp;
      }
    }
    // 此时中轴数的正确位置应该在i+1,将其归位.
    // 思考为什么是i+1而不是i.
    int temp = data.at(i+1);
    data.at(i+1) = data.at(right);
    data.at(right) = temp;
    // 返回中轴数的正确索引.
    return i+1;
  }

  void sort::sort_quick_non_recursive(std::vector<int> &data, int left, int right)
  {
    // 思想：
    // 在元素序列上直接操作;
    // 每次在无序序列中选取一个数,一般称之为中轴数,
    // 将元素序列分成两个部分,使得一部分的元素全都小于等于另一部分的所有元素;
    // 也就是说将序列分成小于等于中轴数和大于等于中轴数的两部分,使得中轴数变为有序;
    // 再递归的对分成的两部分进行划分操作.

    // 非递归利用栈来实现.
    // 利用栈来存储子序列的起点后终点(其实递归也是通过调用系统堆栈来保护调用现场的).
    std::stack<int> s;
    if(left < right)
    {
      // 找到中轴数的索引.
      int index = partition(data, left, right);
      // 如果中轴数索引两个分区存在,则将起点和终点入栈.
      if(index - 1 > left)
      {
        // 下面的入栈顺序要和此处一致.
        s.push(left);
        s.push(index - 1);
      }
      if(index + 1 < right)
      {
        s.push(index + 1);
        s.push(right);
      }
      // 从栈里面取出序列并找到该序列中轴数的正确索引.
      while(!s.empty())
      {
        // 注意顺序.
        int r = s.top();
        s.pop();
        int l = s.top();
        s.pop();
        index = partition(data, l, r);
        // 将新的序列区间入栈.
        if(index - 1 > l)
        {
          s.push(l);
          s.push(index - 1);
        }
        if(index + 1 < r)
        {
          s.push(index + 1);
          s.push(r);
        }
      }
    }
  }