C ++快速排序在一个函数中有2个参数（___ _____，int length）

Question

我的任务是在一个具有2个参数（___ ____，int length）的函数中实现一个Quicksort。 我有一个代码片段，我必须实现快速排序。

#include <cstdlib>
#include <iostream>

void qsort(___ ____, int length);

int main(int argc,char** argv){
    int array[127];
    for(int i = 0; i < 127; ++i)
    {
        array[i] = rand();
    }

    qsort(____, 127);

    for(int i = 0; i < 127; ++i)
    {
        std::cout << array[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}


void qsort(___ ____, int right){
....
}

我对qsort的方法是：

void qsort( int *array, int right){
    std::vector<int> less;
    std::vector<int> equal;
    std::vector<int> greater;

    if (right <= 1){
        return;
    }
    else
    {
        int mid = right/2;
        int pivot = arr[mid];
        for (int i = 0; i < 127; i++)
        {
            if (array[i] < pivot){
                less.push_back(arr[i]);
            }
            if (array[i] == pivot){
                equal.push_back(arr[i]);
            }
            if (array[i] > pivot){
                greater.push_back(arr[i]);
            }
        }
        int *less_a = less.data();
        int *equal_a = equal.data();
        int *greater_a = greater.data();

        qsort(less_a, sizeof(less_a));
        qsort(greater_a, sizeof(greater_a));
        array = less_a + equal_a + greater_a;

}

}

我知道其中存在多个语法错误，但＆＃34;通用逻辑应该很好＆＃34;。

我的第一个问题是qsort获取一个数组作为参数，因为如果我查看哪个元素大于或小于数据透视表，我不能使用数组，因为我不知道它们的大小。所以我想我可以用向量做一个解决方法，最后我把它们转换成数组...

我的第二个问题是qsort必须是无效的，所以我不知道最后如何操纵数组......

在我看来，qsort（）的第一个参数必须是数组。 最后的构想也是错误的，它只是一个占位符＆＃34;对于实际的构想。

我很高兴有任何帮助:) 我在python中实现了这个解决方案，它工作正常，我也可以上传它，如果有人想看到它，但我无法在c ++中实现它

Answer 1

快速排序是就地操作。意味着您将仅修改原始数组。无需创建额外的数组。这是你们两个问题的答案。

试试此代码

void qsort(int* xArray, int xSize)
{
        int lPivot = xArray[xSize-1];
        int lIndexOfLargestElement = 0;
        for (int i = 0; i < xSize-1; i++)
        {
                if (xArray[i] < lPivot)
                {
                        // Swap largest element with this
                        int lTmp = xArray[i];
                        xArray[i] = xArray[lIndexOfLargestElement];
                        xArray[lIndexOfLargestElement]  = lTmp;
                        lIndexOfLargestElement++;
                }
        }
        // swap pivot with xArray[lIndexOfLargestElement]
        int lTmp = xArray[lIndexOfLargestElement];
        xArray[lIndexOfLargestElement] = xArray[xSize-1];
        xArray[xSize-1] = lTmp;
        if (lIndexOfLargestElement > 1)
                qsort(xArray, lIndexOfLargestElement);
        if (xSize-lIndexOfLargestElement-1 > 1)
                qsort(xArray+lIndexOfLargestElement+1, xSize-lIndexOfLargestElement-1);
}