一些迭代后，快速排序算法就地崩溃

Question

我已经实现了以下快速排序算法来对几个点（3D 空间）进行排序。 每对定义一条线：目的是将所有距离小于或等于 powR 的线放在包含所有对的数组附近。 包含坐标的数组是一维的，每 6 个元素定义一对，每 3 个元素定义一个点。

当我使用包含 3099642 个元素的数组运行算法时，在处理 2799222 尝试进入下一次迭代后停止。如果我从元素 2799228 开始算法，它将在 3066300 处停止。 我不知道问题出在哪里，建议？

void QuickSort(float *array, int from, int to, float powR){

float pivot[6];
float temp[6];

float x1;
float y1;
float z1;
float x2;
float y2;
float z2;
float d12;

int i;
int j;

if(from >= to)
    return;

pivot[0] = array[from+0];
pivot[1] = array[from+1];
pivot[2] = array[from+2];
pivot[3] = array[from+3];
pivot[4] = array[from+4];
pivot[5] = array[from+5];

i = from;

for(j = from+6; j <= to; j += 6){

    x1 = pivot[0] - array[j+0];
    y1 = pivot[1] - array[j+1];
    z1 = pivot[2] - array[j+2];
    x2 = pivot[3] - array[j+3];
    y2 = pivot[4] - array[j+4];
    z2 = pivot[5] - array[j+5];
    d12 = (x1*x1 + y1*y1 + z1*z1) + (x2*x2 + y2*y2 + z2*z2);
/*the sorting condition i am using is the regular euclidean norm*/
    if (d12 <= powR){
                i += 6;

                temp[0] = array[i+0];
                temp[1] = array[i+1];
                temp[2] = array[i+2];
                temp[3] = array[i+3];
                temp[4] = array[i+4];
                temp[5] = array[i+5];

                array[i+0] = array[j+0];
                array[i+1] = array[j+1];
                array[i+2] = array[j+2];
                array[i+3] = array[j+3];
                array[i+4] = array[j+4];
                array[i+5] = array[j+5];

                array[j+0] = temp[0];
                array[j+1] = temp[1];
                array[j+2] = temp[2];
                array[j+3] = temp[3];
                array[j+4] = temp[4];
                array[j+5] = temp[5];
    }
}

QuickSort(array, i+6, to, powR);
}

函数以这种方式调用： float LORs = (float) calloc((unsigned)tot, sizeof(float));

LORs 已填充从文件中读取数据，并且工作正常。

QuickSort(LORs, 0, 6000, powR);

    free(LORs);

Answer 1

for(j = from+6; j <= to; j += 6) {
    array[i+0] = array[j+0];
    array[i+1] = array[j+1];
    array[i+2] = array[j+2];
    array[i+3] = array[j+3];
    array[i+4] = array[j+4];
    array[i+5] = array[j+5];
}

当您接近终点时，您的 j + constant_number 将变为 out of bounds。这就是它最终崩溃的原因。请注意，constant_number 是非负数。

当j 接近（您可以通过增量步骤找到多接近，即+6）到数组末尾时，它肯定会超出范围。

举个简单的例子，最大值j可以得到。那就是你的数组的大小。 所以，我们就叫它N吧。

那么，当j等于N时，你就要进入循环了。

那么，你要访问array[j + 0]，其实就是array[N + 0]，也就是array[N]。

我很确定，您知道 C 中的索引（将来应该包含在问题的标签中）是从 0 到 N - 1。等等..

编辑：正如 cmets 所建议的，这不是（快速）排序！

我已经实现了 quickSort here，你想了解一下吗？我建议你从解释开始，而不是从代码开始！