试图用C ++编写快速排序算法并出现错误

如何解决试图用C ++编写快速排序算法并出现错误

所以我试图用向量在c ++中编写quicksort算法。

template <typename T>
T qsort(vector<T> arr) 
{
    int mid_idx = round(arr.size() / 2);
    int root_el = arr[mid_idx];
    
    vector<T> smaller;
    vector<T> bigger;
    vector<T> equals;
    for (T i: arr)
    {
        if (arr[i] > root_el)
            bigger.push_back(arr[i]);
        else if (arr[i] < root_el)
            smaller.push_back(arr[i]);
        else
            equals.push_back(arr[i]);
    }
    return (qsort(smaller) + equals + qsort(bigger));
}

我收到此错误：

invalid operands to binary expression ('int' and 'vector<int>') [Semantic Issue]

那么你能告诉我哪里出问题了吗？

解决方法

此C ++代码存在一些问题。

qsort模板函数显然打算从最后的return指令返回一个向量。但是它被声明为返回单个T类型的对象。

此外，向量参数通过 value 传递，这对于大型向量（复制）而言非常昂贵。我建议改为通过引用传递它。

因此我们可以将顶部声明更改为：

template <typename T>
vector<T>  qsort(vector<T>& arr) 
{

一个更基本的问题：从代码中看来，每次对qsort的调用都会无条件地递归地导致对qsort的两次调用。如果以这种方式编写函数，则程序无法终止。或者更确切地说，操作系统将在耗尽堆栈空间后将其杀死，从而进行一些非法的内存访问。

每个递归算法都需要一些终止条件。在我们的例子中，如果数组的大小小于2，则无事可做，因为它显然已经排序了。

因此qsort函数的开始可以这样写：

#include  <vector>
#include  <cmath>
#include  <iostream>

using  std::vector;

template <typename T>
vector<T>  qsort(vector<T>& arr) 
{
    if (arr.size() < 2)
        return arr;  // so small it is already sorted !

此外，在for循环中，变量i用作整数索引，但声明为T类型的对象。可以这样编写循环：

    for (int i = 0; i < arr.size(); i++)
    {
        if (arr[i] > root_el)
            bigger.push_back(arr[i]);
        else if (arr[i] < root_el)
            smaller.push_back(arr[i]);
        else
            equals.push_back(arr[i]);
    }

现在，我们进入最后的return指令：

    return (qsort(smaller) + equals + qsort(bigger));

上面的代码行显然假定对于向量，“ +”运算符表示向量级联。但是实际上，这在C ++标准中尚未定义。因此，即使在包含<vector>头文件之后，作用域中的向量“ +”也没有定义。

此外，如果国际C ++标准化委员会曾提出过对向量进行“ +”标准化的问题，那么将存在巨大的压力，特别是来自计算物理学界的压力，要求以传统方式进行定义在常见的数学和物理教科书中可以找到。

也就是说，[10,20,30] + [2,4,6]的值必须为[12,24,36]，而不是 [10,30,2,6]，就像您的代码所暗示的那样。

因此，我们必须使用insert STL方法，例如手动进行向量级联：

    auto  lts = qsort(smaller);
    auto  gts = qsort(bigger);

    // concatenate sorted vectors:
    lts.insert(lts.end(),equals.begin(),equals.end());
    lts.insert(lts.end(),gts.begin(),gts.end());

    return lts;

总体而言，以下版本的代码按预期工作：

template <typename T>
vector<T>  qsort(vector<T>& arr) 
{
    if (arr.size() < 2)
        return arr;  // so small it is already sorted !

    int  mid_idx  =  arr.size() / 2;
    T    root_el  =  arr[mid_idx];

    vector<T>  smaller;
    vector<T>  bigger;
    vector<T>  equals;

    for (int i = 0; i < arr.size(); i++)
    {
        if (arr[i] > root_el)
            bigger.push_back(arr[i]);
        else if (arr[i] < root_el)
            smaller.push_back(arr[i]);
        else
            equals.push_back(arr[i]);
    }

    auto  lts = qsort(smaller);
    auto  gts = qsort(bigger);

    // concatenate sorted vectors:
    lts.insert(lts.end(),gts.end());

    return lts;
}

测试代码：

int main()
{

    vector<int>  v1 { 609,396,620,173,742,996,880,125,478,745,206,798,998,124,960,175  };

    vector<int>  v2 = qsort(v1);

    for (auto m : v2) {
        std::cout << m << ' ';
    }
    std::cout << std::endl;

    return EXIT_SUCCESS;
}

程序输出：

$ ./q64784877.x
124 125 173 175 206 396 478 609 620 742 745 798 880 960 996 998 
$ 

关于效率的注意事项：

您的代码创建了许多临时向量，因此可以动态分配大量内存。如果您查看traditional versions of Quicksort，则代码不会分配任何额外的内存。它可以在初始数组中完成所有工作，但是这会使算法稍微复杂些。

此外，上面的代码使用递归到最底端，仅当子矢量减小到1时才停止。实际上，切换到非矢量可能更有效递归，更简单的算法，例如当子数组大小减小到10或15时的Insertion Sort。要在您的平台上测试其确切的最佳阈值。