Delphi 速递剧

我的头可能会撞到墙上。我不明白为什么我下面的快速排序算法不起作用。它是用帕斯卡语写的：

program quicksort;

Type iArray = array [0..8] of integer;
var intArray, newArray : iArray;

Function getIntArray(localIntArray : iArray) : iArray;
begin
  localIntArray[0] := 3;
  localIntArray[1] := 1;
  localIntArray[2] := 8;
  localIntArray[3] := 4;
  localIntArray[4] := 9;
  localIntArray[5] := 0;
  localIntArray[6] := 8;
  localIntArray[7] := 2;
  localIntArray[8] := 5;
  getIntArray := localIntArray;
end;

Procedure writeArray(localIntArray : iArray);
var i:integer;
begin
  for i:=low(localIntArray) to high(localIntArray) do begin
      write(localIntArray[i]);
  end;
  writeln('');
end;

Procedure quicksort(links : integer ; rechts:integer; localIntArray : iArray); 
// links:      Index des 1. Elements, rechts: Index des letzten Elements
var l, r, pivot, pivotValue, temp : Integer;


    Function swap (larray : iArray; links :integer; rechts:integer) : iArray;                                 
    // Ich tausche in einem IntegerArray die Positionen links und rechts
    var temp : integer;
    begin
        temp                    := larray[links];
        larray[links]           := larray[rechts];
        larray[rechts]          := temp;
        swap                    := larray;
    end;

begin
  if (rechts>links) then begin
    l:= links;
    r:= rechts;
    pivot := localIntArray[(rechts+links) div 2];

    while (l<r) do begin
       while localIntArray[l] < pivot do l:=l+1;
       while localIntArray[r] > pivot do r:=r-1;
       if (l<=r) then begin
         localIntArray := swap(localIntArray,l,r);
         l := l+1;
         r := r-1;
       end;
    end;

    if (links < r) then quicksort(links, r, localIntArray);
    if (rechts > l) then quicksort(l, rechts, localIntArray);

    writeln('s Array: ');
    writeArray(localIntArray);
  end;
end;

var i : integer;
begin

  intArray := getIntArray(intArray);
  writeln('Unsortiertes Array: ');
  writeArray(intArray);
  quicksort(low(intArray), high(intArray), intArray);

end.

程序快速排序；
iArray类型=整数的数组[0..8]；
var intArray，newArray:iArray；
函数getIntArray（localIntArray:iArray）：iArray；
开始
localIntArray[0]：=3；
localIntArray[1]：=1；
localIntArray[2]：=8；
localIntArray[3]：=4；
localIntArray[4]：=9；
localIntArray[5]：=0；
localIntArray[6]：=8；
localIntArray[7]：=2；
localIntArray[8]：=5；
getIntArray:=本地阵列；
结束；
程序写入通道（本地通道：iArray）；
varⅠ：整数；
开始
对于i:=低（本地阵列）到高（本地阵列）确实开始
写入（本地数组[i]）；
结束；
书面语（“”）；
结束；
过程快速排序（链接：整数；记录：整数；局部数组：iArray）；
//链接：索引des1。元素，rechts：元素索引
变量l，r，pivot，pivotValue，temp:Integer；
函数交换（larray:iArray；links:integer；rechts:integer）：iArray；
//我在链接和记录的集成阵列中的位置不正确
var-temp：整数；
开始
温度：=larray[links]；
larray[links]：=larray[rechts]；
larray[rechts]：=温度；
swap:=larray；
结束；
开始
如果（rechts>links），则开始
l:=链接；
r:=rechts；
枢轴：=局部阵列[（rechts+链接）分区2]；
而（l）轴dor:=r-1；
如果是（l），则快速排序（l，rechts，localIntArray）；
writeln（'s数组：'）；
书面授权（本地授权）；
结束；
结束；
varⅠ：整数；
开始
intArray:=getIntArray（intArray）；
writeln（'unsortertes数组：'）；
书面授权（intArray）；
快速排序（低（intArray）、高（intArray）、intArray）；
结束。

当我输入数组时：

3,1,8,4,9,0,8,2,5

我收到以下计算结果：

0,1,2,3,5,4,8,8,9

>

0,1,2,3,5,4,4,8,9

3,1,2,0,4,5,8,9

3,1,2,0,4,5,8,8,8,9

3,1,2,0,4,5,8,8,9

 >这里发生了什么？
 你的程序失败了，因为你操作数组的副本，而不是在原地操作。所以请考虑<代码> > QuaskOrth< /C> >：

Procedure quicksort(links, rechts: integer; localIntArray: iArray);

数组是按值传递的。您将数组传递到过程中，但调用者永远看不到对数组所做的任何更改。相反，您需要通过传递对数组的引用来就地操作。这是一个
var
参数：

Procedure quicksort(links, rechts: integer; var localIntArray: iArray);

您需要对
swap
过程执行同样的操作，该过程应声明如下：

Procedure swap(var larray: iArray; links, rechts: integer);

以下是正确排序的完整程序：

program quicksort24335585;

Type
  iArray = array [0 .. 8] of integer;

var
  intArray: iArray;

Function getIntArray(localIntArray: iArray): iArray;
begin
  localIntArray[0] := 3;
  localIntArray[1] := 1;
  localIntArray[2] := 8;
  localIntArray[3] := 4;
  localIntArray[4] := 7;
  localIntArray[5] := 0;
  localIntArray[6] := 8;
  localIntArray[7] := 2;
  localIntArray[8] := 5;
  getIntArray := localIntArray;
end;

Procedure writeArray(localIntArray: iArray);
var
  i: integer;
begin
  for i := low(localIntArray) to high(localIntArray) do
  begin
    write(localIntArray[i], ' ');
  end;
  writeln('');
end;

Procedure quicksort(links: integer; rechts: integer; var localIntArray: iArray);
// links:      Index des 1. Elements, rechts: Index des letzten Elements
var
  l, r, pivot: integer;

  procedure swap(var larray: iArray; links: integer; rechts: integer);
  // Ich tausche in einem IntegerArray die Positionen links und rechts
  var
    temp: integer;
  begin
    temp := larray[links];
    larray[links] := larray[rechts];
    larray[rechts] := temp;
  end;

begin
  if (rechts > links) then
  begin
    l := links;
    r := rechts;
    pivot := localIntArray[(rechts + links) div 2];

    while (l < r) do
    begin
      while localIntArray[l] < pivot do
        l := l + 1;
      while localIntArray[r] > pivot do
        r := r - 1;
      if (l <= r) then
      begin
        swap(localIntArray, l, r);
        l := l + 1;
        r := r - 1;
      end;
    end;

    if (links < r) then
      quicksort(links, r, localIntArray);
    if (rechts > l) then
      quicksort(l, rechts, localIntArray);
  end;
end;

begin
  intArray := getIntArray(intArray);
  writeln('Unsortiertes Array: ');
  writeArray(intArray);

  quicksort(low(intArray), high(intArray), intArray);

  writeln('s Array: ');
  writeArray(intArray);

  Readln;
end.

程序quicksort24335585；
类型
iArray=整数的数组[0..8]；
变量
阵列：iArray；
函数getIntArray（localIntArray:iArray）：iArray；
开始
localIntArray[0]：=3；
localIntArray[1]：=1；
localIntArray[2]：=8；
localIntArray[3]：=4；
localIntArray[4]：=7；
localIntArray[5]：=0；
localIntArray[6]：=8；
localIntArray[7]：=2；
localIntArray[8]：=5；
getIntArray:=本地阵列；
结束；
程序写入通道（本地通道：iArray）；
变量
i：整数；
开始
对于i:=低（本地阵列）到高（本地阵列）do
开始
写入（本地数组[i]，''；
结束；
书面语（“”）；
结束；
过程快速排序（链接：integer；rechts:integer；var localIntArray:iArray）；
//链接：索引des 1.元素，记录：索引des letzten元素
变量
l、 r，pivot：整数；
过程交换（var-larray:iArray；links:integer；rechts:integer）；
//我在链接和记录的集成阵列中的位置不正确
变量
温度：整数；
开始
温度：=larray[links]；
larray[links]：=larray[rechts]；
larray[rechts]：=温度；
结束；
开始
如果（rechts>links），则
开始
l:=链接；
r:=rechts；
枢轴：=局部阵列[（rechts+链接）分区2]；
而（lpivot do
r:=r-1；
如果（l）那么
快速排序（l、rechts、Localintaray）；
结束；
结束；
开始
intArray:=getIntArray（intArray）；
writeln（'unsortertes数组：'）；
书面授权（intArray）；
快速排序（低（intArray）、高（intArray）、intArray）；
writeln（'s数组：'）；
书面授权（intArray）；
Readln；
结束。

输出

Unsortiertes Array:
3 1 8 4 7 0 8 2 5
s Array:
0 1 2 3 4 5 7 8 8
非排序数组：
3 1 8 4 7 0 8 2 5
s数组：
0 1 2 3 4 5 7 8 8
我很确定这个程序可以被完善和改进。这样做将是你学习曲线的一部分！
为什么你不把数组作为
var
参数，用于
quicksort
和
swap
？我想给出+1问题，因为它几乎是一个完整的代码示例，但我们不知道
iArray
是什么。不管怎样，@500 InternalServerError是正确的，你不应该像你那样到处复制数组。另请参阅本文，@David:iArray显然是一个整数数组。@MasonWheeler这样提问者可以改进问题以包括SSCE，我们可以利用一整套事实写出好的答案。没有人需要这样做猜猜看。这样一个问题值得很多人投票。我不明白你为什么鼓励人们发布不完整的代码。哦，天哪。就是这样！这周的“参考与价值”一章更有意义=）非常感谢。明天我将用pass by reference重新编码，以保存这些知识。我在上面睡了一觉，想从头开始重新编码，用call by reference变量实现您的提示。我再也找不到任何失败。我将代码与您的程序逐一进行比较，但找不到问题所在。我在原始问题中添加了新代码，该问题在编译/运行期间产生了一个异常（外部：地址11602处的SIGSEV），我无法对该新代码进行注释。我看不见。没有地方可供选择