C++ 具有两个循环的划分算法c++；

我得到了分区算法的伪代码，但我不确定如何实现它

下面是伪代码和我的实现。请让我知道这是否正确/解释它在做什么。现在我对它有一部分理解，但它是不正确的

输入：0.963,0.003,0.0251,0.353,0.667,0.838,0.335,0.915,0.796,0.833,0.345,0.871,0.089,0.888,0.701,0.735

预计：0.003 0.0251 0.089 0.335 0.345 0.353 0.667 0.701 0.735 0.796 0.833 0.838 0.871 0.888 0.915 0.963

实际值：0.003000 0.025100 0.353000 0.667000 0.838000 0.335000 0.915000 0.796000 0.833000 0.345000 0.871000 0.089000 0.888000 0.71000 0.735000 0.963000

int分区_数据（浮点扩展数据[]，int数据，浮点xmiddle）{
int左；
国际权利；
int j，i；
浮子温度；
对于（i=0；i=xmidle；j--）{
如果（左==右）{
右-=1；
}
否则{
温度=扩展数据[j]；
扩展数据[j]=扩展数据[i]；
扩展数据[i]=温度；
右-=1；
如果（左==右）{
左+=1；
打破
}
}
}
}
}
}

正如其他人已经说过的，无论是在这里还是在代码审查时，伪代码都是非常不标准的，并且很难阅读（尽管它不是真的，它是错误缩进的）

但是，如果您对改进它不感兴趣，而只是想“按原样”实现它，那么下面将逐字翻译成C语言：

int Partition(float X[], int ndata, float xmiddle)
{
    int left  = 0;
    int right = ndata - 1;
    while(1) {              // 'left' loop
        if(X[left] < xmiddle)
        {
            if(left == right)
                return left + 1;
            left ++;
        }
        else
            while(1) {     // 'right' loop
                if(X[right] >= xmiddle)
                {
                    if(left == right)
                        return left;
                    right --;
                }
                else
                {
                    float tmp = X[left];    // these three lines
                    X[left] = X[right];     // swap the two values
                    X[right] = tmp;         // X[left] and X[right]

                    right --;
                    if(left == right)
                        return left + 1;
                    left ++;
                    break;           // exit the 'right' loop
                }
            }     // end of 'right' loop
    }   // end of 'left' loop
} // end of Parition

int分区（浮点X[]，int数据，浮点xmiddle）
{
int左=0；
int right=ndata-1；
while（1）{/'左'循环
if（X[左]=xmidle）
{
如果（左==右）
左转；
对--；
}
其他的
{
float tmp=X[左]；//这三行
X[left]=X[right]；//交换这两个值
X[右]=tmp；//X[左]和X[右]
对--；
如果（左==右）
返回左+1；
左++；
break；//退出“right”循环
}
}//右循环结束
}//左循环结束
}//分区结束

---

<代码>实际上是C，C++中，您可以将其作为一个函数模板，它有一个类型参数，而不是显式<代码>浮点，这样函数就可以划分不同类型的数组（只要操作符<代码> <代码和代码>＝/COD>定义）。您还可以使用

std:：swap

高效地交换数据，并删除显式

tmp

变量。

可能是为了实现完整的快速排序

使用常规预增量/预减量霍尔分区方案的快速排序：

int Partition(float x[], int lo, int hi)
{
float xmiddle = x[(lo+hi)/2];
int left = lo - 1;
int right = hi + 1;
float tmp;
    while (1){
        while (x[++left]  < xmiddle);
        while (x[--right] > xmiddle);
        if(left >= right)
            break;
        tmp = x[left];
        x[left] = x[right];
        x[right] = tmp;
    }
    return right;
}

void QuickSort(float x[], int lo, int hi){
int pivot;
    if (lo < hi){
        pivot = Partition(x, lo, hi);
        QuickSort(x, lo, pivot);
        QuickSort(x, pivot+1, hi);
    }
}

int分区（浮点x[]，int低，int高）
{
浮点xmidle=x[（低+高）/2]；
int left=lo-1；
int right=hi+1；
浮动tmp；
而(1){
而（x[++左]xmidle）；
如果（左>=右）
打破
tmp=x[左]；
x[左]=x[右]；
x[右]=tmp；
}
返还权；
}
无效快速排序（浮点x[]，整数低位，整数高位）{
int轴；
如果（低<高）{
枢轴=分区（x、lo、hi）；
快速排序（x、lo、枢轴）；
快速排序（x，pivot+1，hi）；
}
}

快速排序的一个问题是，分区方案中的一个小错误可能适用于大多数数据模式，而只适用于特定的数据模式，因此很难确定快速排序是否真正没有错误

使用上面psuedo代码的修改版本进行快速排序。这适用于示例数据，但我不确定它是否没有bug。分区应返回一个指向值==xmidle的索引：

int Partition(float X[], int lo, int hi)
{
    int left  = lo;
    int right = hi;
    float xmiddle = X[(lo+hi)/2];
    float tmp;
    while(1) {
        while(X[left] < xmiddle){
            if(left == right)
                return left+1;
            left++;
        }
        while(X[right] >= xmiddle){
            if(left == right)
                return left;
            right--;
        }
        tmp      = X[left];
        X[left]  = X[right];
        X[right] = tmp;
        right --;
        if(left == right)
            return left + 1;
        left ++;
    }
}

void QuickSort(float x[], int lo, int hi){
int pivot;
    if (lo < hi){
        pivot = Partition(x, lo, hi);
        QuickSort(x, lo, pivot);
        QuickSort(x, pivot+1, hi);
    }
}

int分区（浮点X[]，int低，int高）
{
int左=低；
int right=hi；
浮点xmidle=X[（低+高）/2]；
浮动tmp；
而(1){
while（X[左]=xmidle）{
如果（左==右）
左转；
对--；
}
tmp=X[左]；
X[左]=X[右]；
X[右]=tmp；
对--；
如果（左==右）
返回左+1；
左++；
}
}
无效快速排序（浮点x[]，整数低位，整数高位）{
int轴；
如果（低<高）{
枢轴=分区（x、lo、hi）；
快速排序（x、lo、枢轴）；
快速排序（x，pivot+1，hi）；
}
}

算法说明

例程重新排列数据，使小于提供的

xmidle

值的项目保留在数组的左侧（索引较小），而大于

xmidle

的项目保留在右侧（索引较大）。返回值是左侧部分的长度

变量

left

和

right

从数组的两端扫描数组，以查找应该交换的项

“左循环”（从第4行开始）递增

left

索引，直到找到大于或等于

xmidle

（第5行）的项，或者直到到达

right

位置（第6行）。由于

right

最初是数组的最后一个索引（以后只能递减），因此循环最终必须停止递增

left

如果

left

索引满足

right

的要求，则

left

下和

left

处的所有项目都小于

xmidle

，因此

left+1int Partition(float X[], int lo, int hi)
{
    int left  = lo;
    int right = hi;
    float xmiddle = X[(lo+hi)/2];
    float tmp;
    while(1) {
        while(X[left] < xmiddle){
            if(left == right)
                return left+1;
            left++;
        }
        while(X[right] >= xmiddle){
            if(left == right)
                return left;
            right--;
        }
        tmp      = X[left];
        X[left]  = X[right];
        X[right] = tmp;
        right --;
        if(left == right)
            return left + 1;
        left ++;
    }
}

void QuickSort(float x[], int lo, int hi){
int pivot;
    if (lo < hi){
        pivot = Partition(x, lo, hi);
        QuickSort(x, lo, pivot);
        QuickSort(x, pivot+1, hi);
    }
}