这是一项家庭作业。我最终会将这些代码翻译成MIPS程序集，但这对我来说很容易。我已经调试了几个小时和几个小时的代码，并且已经去过我教授的办公时间，但我仍然无法使我的快速排序算法工作。以下是代码以及关于我认为问题领域在哪里的一些评论：
// This struct is in my .h file
typedef struct {
// v0 points to the first element in the array equal to the pivot
int *v0;
// v1 points to the first element in the array greater than the pivot (one past the end of the pivot sub-array)
int *v1;
} PartRet;
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
PartRet partition(int *lo, int *hi) {
// Will later be translating this to MIPS where 2 values can be returned. I am using a PartRet struct to simulate this.
PartRet retval;
// We must use the last item as the pivot
int pivot = *hi;
int *left = lo;
// Take the last value before the pivot
int *right = hi - 1;
while (left < right) {
while((left < hi) && (*left <= pivot)) {
++left;
}
while((right > lo) && (*right > pivot)) {
--right;
}
if (left < right) {
swap(left++, right--);
}
}
// Is this correct? left will always be >= right after the while loop
if (*hi < *left) {
swap(left, hi);
}
// MADE CHANGE HERE
int *v0 = hi;
int *v1;
// Starting at the left pointer, find the beginning of the sub-array where the elements are equal to the pivot
// MADE CHANGE HERE
while (v0 > lo && *(v0 - 1) >= pivot) {
--v0;
}
v1 = v0;
// Starting at the beginning of the sub-array where the elements are equal to the pivot, find the element after the end of this array.
while (v1 < hi && *v1 == pivot) {
++v1;
}
if (v1 <= v0) {
v1 = hi + 1;
}
// Simulating returning two values
retval.v0 = v0;
retval.v1 = v1;
return retval;
}
void quicksort(int *array, int length) {
if (length < 2) {
return;
}
PartRet part = partition(array, array + length - 1);
// I *think* this first call is correct, but I'm not sure.
int firstHalfLength = (int)(part.v0 - array);
quicksort(array, firstHalfLength);
int *onePastEnd = array + length;
int secondHalfLength = (int)(onePastEnd - part.v1);
// I have a feeling that this isn't correct
quicksort(part.v1, secondHalfLength);
}
我甚至尝试使用在线代码示例重写代码，但要求是使用lo和hi指针但没有我发现的代码样本使用它。当我调试代码时，我最终只能使代码适用于某些数组而不是其他数组，尤其是当数组是数组中最小的元素时。
答案 0 :(得分：1)
分区代码存在问题。以下是4个简单的测试输出，来自下面的SSCCE代码：
array1:
Array (Before):
[6]: 23 9 37 4 2 12
Array (First half partition):
[3]: 2 9 4
Array (First half partition):
[1]: 2
Array (Second half partition):
[1]: 9
Array (Second half partition):
[2]: 23 37
Array (First half partition):
[0]:
Array (Second half partition):
[1]: 23
Array (After):
[6]: 2 4 9 12 37 23
array2:
Array (Before):
[3]: 23 9 37
Array (First half partition):
[1]: 23
Array (Second half partition):
[1]: 9
Array (After):
[3]: 23 37 9
array3:
Array (Before):
[2]: 23 9
Array (First half partition):
[0]:
Array (Second half partition):
[1]: 23
Array (After):
[2]: 9 23
array4:
Array (Before):
[2]: 9 24
Array (First half partition):
[0]:
Array (Second half partition):
[1]: 9
Array (After):
[2]: 24 9
#include <stdio.h>
typedef struct
{
int *v0; // v0 points to the first element in the array equal to the pivot
int *v1; // v1 points to the first element in the array greater than the pivot (one past the end of the pivot sub-array)
} PartRet;
static void dump_array(FILE *fp, const char *tag, int *array, int size)
{
fprintf(fp, "Array (%s):\n", tag);
fprintf(fp, "[%d]:", size);
for (int i = 0; i < size; i++)
fprintf(fp, " %d", array[i]);
putchar('\n');
}
static void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
static PartRet partition(int *lo, int *hi)
{
// Will later be translating this to MIPS where 2 values can be
// returned. I am using a PartRet struct to simulate this.
PartRet retval;
// This code probably won't ever be hit as the base case in the QS
// function will return first
if ((hi - lo) < 1)
{
retval.v0 = lo;
retval.v1 = lo + (hi - lo) - 1;
return retval;
}
// We must use the last item as the pivot
int pivot = *hi;
int *left = lo;
// Take the last value before the pivot
int *right = hi - 1;
while (left < right)
{
if (*left <= pivot)
{
++left;
continue;
}
if (*right >= pivot)
{
--right;
continue;
}
swap(left, right);
}
// Is this correct? left will always be >= right after the while loop
swap(left, hi);
int *v0 = left;
int *v1;
// Starting at the left pointer, find the beginning of the sub-array
// where the elements are equal to the pivot
while (v0 > lo && *(v0 - 1) == pivot)
{
--v0;
}
v1 = v0;
// Starting at the beginning of the sub-array where the elements are
// equal to the pivot, find the element after the end of this array.
while (v1 < hi && *v1 == pivot)
{
++v1;
}
// Simulating returning two values
retval.v0 = v0;
retval.v1 = v1;
return retval;
}
static void quicksort(int *array, int length)
{
if (length < 2)
{
return;
}
PartRet part = partition(array, array + length - 1);
// I *think* this first call is correct, but I'm not sure.
int firstHalfLength = (int)(part.v0 - array);
dump_array(stdout, "First half partition", array, firstHalfLength);
quicksort(array, firstHalfLength);
int *onePastEnd = array + length;
int secondHalfLength = (int)(onePastEnd - part.v1);
// I have a feeling that this isn't correct
dump_array(stdout, "Second half partition", part.v1, secondHalfLength);
quicksort(part.v1, secondHalfLength);
}
static void mini_test(FILE *fp, const char *name, int *array, int size)
{
putc('\n', fp);
fprintf(fp, "%s:\n", name);
dump_array(fp, "Before", array, size);
quicksort(array, size);
dump_array(fp, "After", array, size);
putc('\n', fp);
}
int main(void)
{
int array1[] = { 23, 9, 37, 4, 2, 12 };
enum { NUM_ARRAY1 = sizeof(array1) / sizeof(array1[0]) };
mini_test(stdout, "array1", array1, NUM_ARRAY1);
int array2[] = { 23, 9, 37, };
enum { NUM_ARRAY2 = sizeof(array2) / sizeof(array2[0]) };
mini_test(stdout, "array2", array2, NUM_ARRAY2);
int array3[] = { 23, 9, };
enum { NUM_ARRAY3 = sizeof(array3) / sizeof(array3[0]) };
mini_test(stdout, "array3", array3, NUM_ARRAY3);
int array4[] = { 9, 24, };
enum { NUM_ARRAY4 = sizeof(array4) / sizeof(array4[0]) };
mini_test(stdout, "array4", array4, NUM_ARRAY4);
return(0);
}
我没有对排序代码进行任何算法更改。我只是添加了dump_array()函数，并对其进行了战略调用，并添加了mini_test()函数和main()。这些类型的灯具非常有用。请注意，当输入数组的大小为2且顺序错误时，分区是正确的，但是当大小为2且顺序正确时，分区会颠倒数组元素的位置。这有问题！解决它，你可能已经修复了其余的大部分。在所有6个排列中使用一些3个元素数组（3个不同的值）;考虑使用3个元素，只有2个不同的值，3个元素和1个值。
答案 1 :(得分：1)
注意：我只是为您发布此内容以了解其他方法。我已经在上面的评论中指出了你的算法中至少有一个缺陷。考虑一下。
带有集成分区的传统就地快速排序通常看起来像下面这样，尽管每个人似乎都有他们的最爱。我更喜欢这样简单（分区和递归在同一个proc中）。最重要的是，对汇编的翻译很简单，但你现在可能已经说过了：
void quicksort(int *lo, int *hi)
{
/* early exit on trivial slice */
size_t len = (hi - lo) + 1;
if (len <= 1)
return;
/* use hi-point for storage */
swap(lo + len/2, hi);
/* move everything in range below pivot */
int *pvt=lo, *left=lo;
for(; left != hi; ++left)
if (*left <= *hi)
swap(left, pvt++);
/* this is the proper spot for the pivot */
swap(pvt, hi);
/* recurse sublists. do NOT include pivot slot. */
quicksort(lo, pvt-1);
quicksort(pvt+1, hi);
}
此算法中唯一的实际变量是如何计算提取初始透视值的“点”。今天的许多实现使用随机点，因为它有助于将快速排序的退化性能扩散到几乎排序的列表中：
swap(lo + (rand() % len), hi);
其他实现就像从切片中间抓取元素一样，正如我在上面的算法中所做的那样：
swap(lo + len/2, hi);
你可能会觉得有趣的是，有些人没有抓住任何中间元素并且完全交换，只是使用在hi-slot中发生的任何东西作为透视值。这减少了代码只需一行，但有一个巨大的警告：它将在几乎排序或完全排序的列表上保证可怕的交换性能（一切都会交换）。
无论如何，如果没有别的，我希望它可以帮助你绕过算法的分区部分试图做的事情：将所有内容推到列表顶部的插槽中的枢轴值以下，尾部上方的所有内容列表，然后递归到这些分区，但最重要的是，不要在 切片的递归中包含数据透视槽。它已经在它需要的地方了（事实上，在那一点上唯一能保证如此）。