Question

我正在尝试解决一种奇怪的QuickSort。我对数组进行分区，然后创建了另外两个数组：左数组和右数组（没有数据透视），我对它们进行分区等等。我的代码是这样的：

#include <bits/stdc++.h>

using namespace std;

int partition(vector<int>& ar) {
     int pivot=ar[0];
     int store=0;
     for(int i=0;i<ar.size();i++)
     {
         if(ar[i]<pivot)
         {
             store++;
             int temp=ar[store];
             ar[store]=ar[i];
             ar[i]=temp;
         }
     }
     for(int i=0;i<store;i++){
         int temp=ar[i];
         ar[i]=ar[i+1];
         ar[i+1]=temp;
     }
     for(int i=ar.size()-2;i>store;i--){
         int temp=ar[i+1];
         ar[i+1]=ar[i];
         ar[i]=temp;
     } 
     return store; }

 void quickSort(vector <int>& arr) {
     if(arr.size()<=1)
     {
         return;
     }
     int a=partition(arr);
     vector <int> vec1(a);
     int b=arr.size()-a-1;
     vector <int> vec2(b);
     for(int i=0;i<a;i++)
     {
         vec1[i]=arr[i];
     }
     for(int i=a+1;i<arr.size();i++)
     {
         vec2[i]=arr[i];
     }
     if(vec1.size()<2 && vec2.size()<2)
     {
         for(int i=0;i<arr.size();i++)
         {
             cout<<arr[i]<<" ";
         }
         cout<<endl;
         return;
     }
     else{
         quickSort(vec1);
         quickSort(vec2);

     }
 }

 int main() {
     int n;
     cin >> n;

     vector <int> arr(n);
     for(int i = 0; i < (int)n; ++i) {
         cin >> arr[i];
     }
     quickSort(arr);
     for(int i =0; i <arr.size(); i++) 
     {
       cout<<arr[i]<<" ";
     }

     return 0; 
 }

代码根本没有完成，但是，在这里，它应该运行，而不是。我有这个错误：

Abort Called

错误（stderr）：

解决方案：malloc.c：2372：sysmalloc：断言（old_top ==（（（mbinptr）（（（char *）＆amp;（（av） - ＆gt; bins [（（1） - 1）* 2] ）） - __builtin_offsetof（struct malloc_chunk，fd））））＆amp;＆amp; old_size == 0）|| （（unsigned long）（old_size）＆gt; =（unsigned long）（（（__ builtin_offsetof（struct malloc_chunk，fd_nextsize））+（（2 *（sizeof（size_t））） - 1））＆amp;〜（（2 * （sizeof（size_t））） - 1）））＆amp;＆amp;（（old_top） - ＆gt; size＆amp; 0x1）＆amp;＆amp;（（unsigned long）old_end＆amp; pagemask）== 0）＆＃39; failed.`

我认为这是因为我正在递归调用函数quickSort，它引用了向量vec1和向量vec2，然后我再次在函数中创建了向量vec1和vec2 ...但我完全不确定!! / p>

对于这么长的问题再次抱歉，但写起来并不容易......

提前感谢您的回答!!!!

Answer 1

if (arr.size() <= 1)
    return;

int a = partition(arr);
vector<int> vec1(a);
for (int i = 0; i<a; i++)
    vec1[i] = arr[i];

int b = arr.size() - a - 1;
vector<int> vec2(b);
for (int i = a + 1; i<(int)arr.size(); i++)
    vec2[i] = arr[i];

显然vec2.size()小于arr.size()。 vec2可以很容易地超出范围，可能vec1

例如，如果arr.size()为10，而b为2，则您尝试设置vec2[3] = arr[3]但vec2只有{2}

要解决此问题，您需要将vec1和vec2的大小设置为与arr相同

vector<int> vec1(arr.size(), 0);
vector<int> vec2(arr.size(), 0);

这将创建相同大小的数组，并将值初始化为零。另外，请确保a和b大于零。我不知道算法如何与qsort相关。请参阅下面的示例了解工作代码。

为方便起见，您可以在main中声明一些随机数组，例如：

vector<int> arr{ 7,3,6,1,4,8,9,2 };

这样，每次要测试算法时，您都不必花费2分钟输入数据。您也可以编写交换函数以避免重复相同的代码，例如

void myswap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

或者只使用std::swap。 qsort示例：

#include <iostream>
#include <vector>

using std::cout;

int qsort_partition(std::vector<int> &arr, const int left, const int right)
{
    const int mid = left + (right - left) / 2;
    const int pivot = arr[mid];

    std::swap(arr[mid], arr[left]);
    int i = left + 1;
    int j = right;
    while (i <= j) 
    {
        while (i <= j && arr[i] <= pivot) 
            i++;

        while (i <= j && arr[j] > pivot) 
            j--;

        if (i < j) 
            std::swap(arr[i], arr[j]);
    }
    std::swap(arr[i - 1], arr[left]);
    return i - 1;
}

void qsort(std::vector<int> &arr, const int left, const int right)
{
    if (left >= right) return;
    int partition = qsort_partition(arr, left, right);
    qsort(arr, left, partition - 1);
    qsort(arr, partition + 1, right);
}

void my_qsort(std::vector<int> &arr)
{
    qsort(arr, 0, arr.size() - 1);
}

int main() 
{
    std::vector<int> arr{ 7,3,6,1,4,8,9,2 };
    my_qsort(arr);
    return 0;
}

QuickSort，通过引用传递，递归

1 个答案: