Question

我在std :: sort中发现了一个错误，尤其是在QuickSort的某些实现中，我不知道问题是否出在一般算法上。

精华

当元素少于16个所有范数时，因为std :: sort使用插入排序。

当元素数量为17个或更多时，将使用快速排序，并从元素数量的对数限制递归深度，但是向量在第一次__introsort_loop迭代时有时间恶化。

许多相同的元素会导致向量损坏。通过用无效的迭代器替换有效的迭代器来发生腐败。

其他容器也可能损坏，我没有检查。

一个简单的示例，其向量类型为“ int”，用于更复杂的对象-在排序时崩溃，因为无效的对象被传递给比较函数：

#include <iostream>
#include <vector>
#include <algorithm>

void quickSort(int arr[], int left, int right) {
  int i = left, j = right;
  int tmp;
  int pivot = arr[(left + right) / 2];

  /* partition */

  while (i <= j) {
        while (arr[i] < pivot)
              i++;
        while (arr[j] > pivot)
              j--;
        if (i <= j) {
              tmp = arr[i];
              arr[i] = arr[j];
              arr[j] = tmp;
              i++;
              j--;
        }
  };

  /* recursion */

  if (left < j)
        quickSort(arr, left, j);

      if (i < right)
            quickSort(arr, i, right);
}

int main()
{
  for( int i = 0 ; i < 1 ; i++ )
  {
    //std::vector<int> v({5, 6, 1, 6, 2, 6, 3, 6, 4, 4, 4, 4, 4, 6, 6, 6, 6, 6, 6});//reproducible with this
    std::vector<int> v(19, 6);//reproducible with this also
    std::sort(std::begin(v), std::end(v), [&v]( const int & left, const int & right )
                                          {
//                                          std::cout << " left=" << left << ", right=" << right << std::endl;
                                            bool b = left <= right;
                                            return b;
                                          }
              );
//    quickSort(v.data(), 0, v.size());
 for( const auto & result : v )
 {
    std::cout << "results: " << result << std::endl;
 }
  }

  std::cout << "Hello World!\n";
}

有人可以快速遇到这种行为吗？

Answer 1

我尝试了您的代码，看来问题出在用构造函数vector（n，val）（填充构造函数）创建的向量上。手动插入16、17、18和19个随机元素时，向量没有问题。

Answer 2

您必须将枢纽保存在开始学习的课上，例如

void quickSort（int arr []，左侧为int，右侧为int）{ int i =左，j =右； int axis = x [left]; 之后将起作用

标准排序使std :: vector无效

2 个答案: