C++ 具有重复密钥的快速排序算法

我正在尝试实现快速排序算法。以下代码适用于唯一元素，但不适用于具有重复元素的数组。请告诉我哪里做错了。另外，当我将pivot的值更改为0以外的其他数字时，程序崩溃。代码如下：

#include <iostream>
#include <cstdlib>

using namespace std;

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

void quicksort(int *arr, int size)
{    
    // these two variables will take care of position of comparison
    int lower = 0, upper = size - 1;  
    int pivot = 0;  // assigns pivot
    if (size <= 1)
        return;

    while (lower < upper)
    {
        while (arr[lower] < arr[pivot])
        {
            ++lower;
        }
    }

    while (arr[upper] > arr[pivot])
    {
        --upper;
    }

    if (upper > lower)
    {
        swapme(arr[upper], arr[lower]);
        // upper--;
        // lower++;
    }

    quicksort(arr, lower);
    quicksort(&arr[lower + 1], size - 1 - lower);
}

int main()
{
    int arr[30];

    for(int j = 0; j < 30; j++)
    {
        arr[j] = 1 + rand() % 5000;
    }

    for(int j = 0; j < 30; j++)
    {
        cout << arr[j] << "\t";
    }
    cout << endl;

    quicksort(arr, 30);

    for(int j = 0; j < 30; j++)
    {
        cout << arr[j] << "\t";
    }
    cout << endl;

    cin.get();
    cin.get();
}

#包括
#包括
使用名称空间std；
无效swapme（内部和a、内部和b）
{
内部温度=a；
a=b；
b=温度；
}
无效快速排序（int*arr，int-size）
{    
//这两个变量将考虑比较的位置
整数下限=0，上限=size-1；
int pivot=0；//分配pivot
if（尺寸arr[枢轴]）
{
--上部；
}
如果（上部>下部）
{
swapme（arr[上]、arr[下]；
//上——；
//低级++；
}
快速排序（arr，较低）；
快速排序（&arr[lower+1]，size-1-lower）；
}
int main（）
{
int-arr[30]；
对于（int j=0；j<30；j++）
{
arr[j]=1+rand（）%5000；
}
对于（int j=0；j<30；j++）
{
cout您正在将pivot元素的索引存储在
pivot
变量中，因此交换元素可能会在循环期间更改pivot元素的选择。这不是一个很好的主意。我建议将pivot元素的实际值存储在
pivot
中

此外，如果这真的不是家庭作业，为什么不直接使用标准的图书馆设施呢

#include <algorithm>

// ...

std::sort(arr + 0, arr + 30);

#包括
// ...
标准：：排序（arr+0，arr+30）；

您将获得经过大量优化和测试的代码，这些代码将在任何时候都优于手写快速排序。
快速排序，可以实现任意数量的i/p整数。它还可以处理重复键
#包括
#包括
使用名称空间std；
无效输入阵列（int*，int）；
无效快速排序（int*，int，int）；
int分区（int*，int，int）；
无效掉期（int*，int，int）；
void printArr（int*，int Siz=11）；
void main（）{
int siz；
库茨；
int*a=新的int[siz]；
输入阵列（a，siz）；
快速排序（a，0，siz-1）；
int i=0，j=11；
printArr（a，siz）；
系统（“暂停”）；
}
无效输入阵列（int*a，int-s）{
对于（int i＝0），通过调试发现了什么？我不知道枢轴位置问题。似乎是无限循环。这不是一个作业，因为我不是CS学生BrgBog:它是C++，而不是java（它可能对有经验的程序员来说是有帮助的，但在我看来，情况并非如此）。关于面试问题的恐怖故事似乎足以激励我。
#include <algorithm>

// ...

std::sort(arr + 0, arr + 30);

#include <conio.h>
#include <string>

using namespace std;
void InputArray(int*,int);
void QuickSort(int *,int,int);
int partition(int *,int,int);
void swap(int *,int,int);
void printArr(int *,int Siz=11);

void main(){

    int siz;
    cout<<"Enter Array length   :   "; cin>>siz; 
    int *a=new int[siz];

    InputArray(a,siz);
    QuickSort(a,0,siz-1);
    int i=0,j=11;

    printArr(a,siz);
    system("pause");

}


void InputArray(int*a,int s){
    for(int i=0; i<s; i++){
        cout<<"ELement ["<<i<<"] =  "; cin>>a[i];
    }

}
void QuickSort(int *a,int start,int end){
    if(start<end){
        int pivot=partition(a,start,end);

        QuickSort(a,start,pivot);
        QuickSort(a,pivot+1,end);
    }


}
int partition(int *a,int start,int end){

    int currentPivotValue=a[start];
    int i=start-1, j=end+1;
    while(true){
        i++;
        while(i<j && a[i]<currentPivotValue){ i++; }
        j--;

        while(j>start && a[j]>currentPivotValue) {j--;}
        if(i<j) swap(a,i,j);        
        else return j;
    }


}
void swap(int *b,int i,int j){
    int t=b[i];
    b[i]=b[j];
    b[j]=t;



}
void printArr(int *a,int Siz){
    for(int i=0; i<Siz; i++) cout<<a[i]<<" "; 
}