分析 C 中的快速排序

Question

我想要做的是在下面获得所需的输出。我尝试在快速排序开始时打印，我得到了一些正确的值，但我觉得我的整个方法不起作用，所以我需要一些帮助。

级别 partitionNumber d [3a_spaces x1 x3 ... xn 3b_spaces]

在哪里：

level 是递归的级别。

partitionNumber 是用于创建分区的编号。

d 是 '>' 如果 partitionNumber 大于 否则分区是'

3a_space 是一组 3 个空格字符，用于 分区开始前的数组。

x1 x3 ... xn 是分区中的数字集合。注意：打印 这些数字使用“%3d”格式描述符。

3b_spaces 是一组 3 个空格字符，每个元素的 分区结束后的数组。

想要的输出：

1  0  [23 13 82 33 51 17 45 75 11 27 ]
2 51> [27 13 33 23 17 45 11          ]
3 23> [11 13 17                      ]
3 23> [11 13 17                      ]
3 23< [            33 45 27          ]
4 45> [            27 33             ]
4 45> [            27 33             ]
3 23< [            27 33 45          ]
2 51> [11 13 17 23 27 33 45          ]
2 51< [                        82 75 ]
2 51< [                        75 82 ]
1  0  [11 13 17 23 27 33 45 51 75 82 ]

我的输出：

1  0  [23 13 82 33 51 17 45 75 11 27 ]
2 51> [27 13 33 23 17 45 11          ]
3 23> [11 13 17                      ]
2 13> [11 13 17                      ]
3 23< [            33 45 27          ]
4 45> [            27 33             ]
3 27? [            27 33             ]
2 45> [            27 33 45          ]
1 23> [11 13 17 23 27 33 45          ]
2 51< [                        82 75 ]
1 82> [                        75 82 ]
0 51> [11 13 17 23 27 33 45 51 75 82 ]






 #include<stdio.h>

int inputLine[10];

void quicksort(int v[], int left, int right, int level, int previousPivotPoint, char d);

int main()
{
  int v[] = { 23, 13, 82, 33, 51, 17, 45, 75, 11, 27 };
  quicksort(v, 0, 9, 0, -1, ' ');



  return 0;
}

void swap(int v[], int i, int j)
{
  int temp;
  temp = v[i];
  v[i] = v[j];
  v[j] = temp;
}

void quicksort(int v[], int left, int right, int level, int previousPivotPoint, char d)
{
  int i, last;

  level++;
  if (previousPivotPoint > v[left]) d = '>';
  else if (previousPivotPoint < v[left]) d = '<';


  if (left >= right)
  {
    level--;
    return;
  }
  if (previousPivotPoint == -1)
  {
    printf("%d  0  [", level);
  } else
  {
    printf("%d %d%c [", level, previousPivotPoint, d);
  }

  previousPivotPoint = v[(left + right) / 2];

  d = '?';
  for (i = 0; i < 10; i++)
  {
    if (i > right || i < left)
    {
      printf("   ");
    } else
    {
      printf("%d ", v[i]);
    }
  }
  printf("]\n");

  swap(v, left, (left + right) / 2);

  last = left;

  for (i = left + 1; i <= right; i++)
  {
    if (v[i] < v[left])
    {
      last++;
      swap(v, last, i);
    }
  }

  swap(v, left, last);
  quicksort(v, left, last - 1, level, previousPivotPoint, d);
  quicksort(v, last + 1, right, level, previousPivotPoint, d);
  level--;


  if (previousPivotPoint > v[left]) d = '>';
  else if (previousPivotPoint < v[left]) d = '<';
  printf("%d %d%c [", level, previousPivotPoint, d);
  previousPivotPoint = v[(left + right) / 2];


  for (i = 0; i < 10; i++)
  {
    if (i > right || i < left)
    {
      printf("   ");
    } else
    {
      printf("%d ", v[i]);
    }
  }
  printf("]\n");

}

Answer 1

我注意到几件事：

1. 如果 level 将是一个模块化变量，而不是传递给快速排序例程的变量，那么它不太可能下降。考虑将其合并到快速排序函数的签名中。
2. 您从i = left 开始 - 这不会打印您的整个原始底层数组。考虑始终检查数组并将它们全部打印出来，检查您是否在当前数组中。
3. 您在快速排序例程中进行了 FORWARD 声明 void swap(int v[], int i, int j);。那是怎么回事？ 注意： 显然它来自 K&R。就个人喜好而言，我不是这个符号的最大粉丝，但你可能比跟随 K&R 做得更糟，是吗？

Answer 2

没有时间深入研究您的代码，但这里有一些 东西。

您应该做的第一件事是将硬编码的10 替换为 #define 常量。

您没有设置d 的值并不奇怪， 因此所有的空间。还有，为什么要把d 设为全局？

您的打印循环应该遍历整个列表，因此 括号将始终保持相同的大小。