我发现了这篇文章How to do iterative quicksort without using stack in c? 但是建议的答案确实使用了内联堆栈数组！ （仅允许恒定数量的额外空间）
答案 0 :(得分：1)
reference页面中的代码大胆声明：
堆栈我的实现未使用堆栈来存储数据...
然而，函数定义中有许多具有自动存储的变量，其中有2个具有1000个条目的数组，这些数组最终将使用固定但数量可观的堆栈空间：
// quickSort
//
// This public-domain C implementation by Darel Rex Finley.
//
// * Returns YES if sort was successful, or NO if the nested
// pivots went too deep, in which case your array will have
// been re-ordered, but probably not sorted correctly.
//
// * This function assumes it is called with valid parameters.
//
// * Example calls:
// quickSort(&myArray[0],5); // sorts elements 0, 1, 2, 3, and 4
// quickSort(&myArray[3],5); // sorts elements 3, 4, 5, 6, and 7
bool quickSort(int *arr, int elements) {
#define MAX_LEVELS 1000
int piv, beg[MAX_LEVELS], end[MAX_LEVELS], i=0, L, R ;
beg[0]=0; end[0]=elements;
while (i>=0) {
L=beg[i]; R=end[i]-1;
if (L<R) {
piv=arr[L]; if (i==MAX_LEVELS-1) return NO;
while (L<R) {
while (arr[R]>=piv && L<R) R--; if (L<R) arr[L++]=arr[R];
while (arr[L]<=piv && L<R) L++; if (L<R) arr[R--]=arr[L]; }
arr[L]=piv; beg[i+1]=L+1; end[i+1]=end[i]; end[i++]=L; }
else {
i--; }}
return YES; }
缩进样式非常混乱。这是重新格式化的版本：
#define MAX_LEVELS 1000
bool quickSort(int *arr, int elements) {
int piv, beg[MAX_LEVELS], end[MAX_LEVELS], i = 0, L, R;
beg[0] = 0;
end[0] = elements;
while (i >= 0) {
L = beg[i];
R = end[i] - 1;
if (L < R) {
piv = arr[L];
if (i == MAX_LEVELS - 1)
return NO;
while (L < R) {
while (arr[R] >= piv && L < R)
R--;
if (L < R)
arr[L++] = arr[R];
while (arr[L] <= piv && L < R)
L++;
if (L < R)
arr[R--] = arr[L];
}
arr[L] = piv;
beg[i + 1] = L + 1;
end[i + 1] = end[i];
end[i++] = L;
} else {
i--;
}
}
return YES;
}
请注意，1000很大，但是对于已经排序的中等大小的数组上的病理情况来说还不够。该函数仅在大小为1000的此类数组上返回NO，这是不可接受的。
一个低得多的值将满足算法的改进版本，该算法将较大范围推入数组，并且循环在较小范围上迭代。这确保了N个条目的数组可以处理2个 N 个条目的集合。在排序数组上，它仍然具有二次时间复杂度，但至少可以对所有可能大小的数组进行排序。
这是经过修改和检测的版本：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX_LEVELS 64
int quickSort(int *arr, size_t elements) {
size_t beg[MAX_LEVELS], end[MAX_LEVELS], L, R;
int i = 0;
beg[0] = 0;
end[0] = elements;
while (i >= 0) {
L = beg[i];
R = end[i];
if (L + 1 < R--) {
int piv = arr[L];
if (i == MAX_LEVELS - 1)
return -1;
while (L < R) {
while (arr[R] >= piv && L < R)
R--;
if (L < R)
arr[L++] = arr[R];
while (arr[L] <= piv && L < R)
L++;
if (L < R)
arr[R--] = arr[L];
}
arr[L] = piv;
if (L - beg[i] > end[i] - R) {
beg[i + 1] = L + 1;
end[i + 1] = end[i];
end[i++] = L;
} else {
beg[i + 1] = beg[i];
end[i + 1] = L;
beg[i++] = L + 1;
}
} else {
i--;
}
}
return 0;
}
int testsort(int *a, size_t size, const char *desc) {
clock_t t = clock();
size_t i;
if (quickSort(a, size)) {
printf("%s: quickSort failure\n", desc);
return 1;
}
for (i = 1; i < size; i++) {
if (a[i - 1] > a[i]) {
printf("%s: sorting error: a[%zu]=%d > a[%zu]=%d\n",
desc, i - 1, a[i - 1], i, a[i]);
return 2;
}
}
t = clock() - t;
printf("%s: %zu elements sorted in %.3fms\n",
desc, size, t * 1000.0 / CLOCKS_PER_SEC);
return 0;
}
int main(int argc, char *argv[]) {
size_t i, size = argc > 1 ? strtoull(argv[1], NULL, 0) : 1000;
int *a = malloc(sizeof(*a) * size);
if (a != NULL) {
for (i = 0; i < size; i++)
a[i] = rand();
testsort(a, size, "random");
for (i = 0; i < size; i++)
a[i] = i;
testsort(a, size, "sorted");
for (i = 0; i < size; i++)
a[i] = size - i;
testsort(a, size, "reverse sorted");
for (i = 0; i < size; i++)
a[i] = 0;
testsort(a, size, "constant");
free(a);
}
return 0;
}
输出：
random: 100000 elements sorted in 7.379ms
sorted: 100000 elements sorted in 2799.752ms
reverse sorted: 100000 elements sorted in 2768.844ms
constant: 100000 elements sorted in 2786.612ms
这是一个字义修饰的版本，对病理病例更具抵抗力：
#define MAX_LEVELS 48
int quickSort(int *arr, size_t elements) {
size_t beg[MAX_LEVELS], end[MAX_LEVELS], L, R;
int i = 0;
beg[0] = 0;
end[0] = elements;
while (i >= 0) {
L = beg[i];
R = end[i];
if (R - L > 1) {
size_t M = L + ((R - L) >> 1);
int piv = arr[M];
arr[M] = arr[L];
if (i == MAX_LEVELS - 1)
return -1;
R--;
while (L < R) {
while (arr[R] >= piv && L < R)
R--;
if (L < R)
arr[L++] = arr[R];
while (arr[L] <= piv && L < R)
L++;
if (L < R)
arr[R--] = arr[L];
}
arr[L] = piv;
M = L + 1;
while (L > beg[i] && arr[L - 1] == piv)
L--;
while (M < end[i] && arr[M] == piv)
M++;
if (L - beg[i] > end[i] - M) {
beg[i + 1] = M;
end[i + 1] = end[i];
end[i++] = L;
} else {
beg[i + 1] = beg[i];
end[i + 1] = L;
beg[i++] = M;
}
} else {
i--;
}
}
return 0;
}
输出：
random: 10000000 elements sorted in 963.973ms
sorted: 10000000 elements sorted in 167.621ms
reverse sorted: 10000000 elements sorted in 167.375ms
constant: 10000000 elements sorted in 9.335ms
结论：
答案 1 :(得分：0)
可以，因为我在fortran IV中实现了快速排序（很久以前，并且在该语言支持递归之前-这是一个赌注）。但是，您确实需要某个地方（需要一个大型阵列）来记住您的状态，因为您需要做一些单独的工作。
递归要容易得多...
答案 2 :(得分：0)
根据定义，Quicksort是一种“分而治之”的搜索算法，其思想是将给定的数组拆分为较小的分区。因此，您将问题分为子问题，这更容易解决。 当使用不带递归的Quicksort时，您需要某种结构来存储您当时不使用的分区。 这就是answer的post使用数组使快速排序不递归的原因。
答案 3 :(得分：0)
quicksort是否可以在C中实现而无需堆栈和递归？
Quicksort要求从每个非平凡分区中遵循两条路径：每个（子）分区的新分区。有关先前分区的信息（作为结果的分区之一的边界）需要转发到每个新分区。那么问题是，这些信息住在哪里？特别是，当程序在另一个分区上工作时，有关一个分区的信息在哪里？
对于串行算法，答案是信息存储在堆栈或队列或其中之一的等效功能中。总是这样，因为这些是我们为满足所需目的的数据结构的名称。特别是，递归是一种特殊情况，而不是替代方案。在递归快速排序中，数据存储在调用堆栈中。对于迭代实现，您可以在形式上实现堆栈，但是可以改用简单且相对较小的数组作为临时堆栈。
但是等同于堆栈和队列的功能远不止于此。例如，您可以将数据附加到文件中，以供以后读取。您可以将其写入管道。您可以通过通信网络将其异步传输给自己。
如果您想发疯，甚至可以嵌套迭代来代替递归。这将对可以处理的数组大小施加硬上限，但并不像您想象的那样严格。通过一些注意和一些技巧，您可以使用25个循环的嵌套来处理十亿个元素的数组。如此深的巢穴将是丑陋而疯狂的，但是仍然可以想象得到。一个人可以手写。在那种情况下，一系列嵌套循环作用域以及它们的块作用域变量就相当于堆栈。
所以答案取决于您所说的“无堆栈”的确切含义：
答案 4 :(得分：0)