RAD Studio 10.3.3 测试√

快速排序思路：

1、快速排序是一种递归的写法
2、其中需要在待排序的数组中找到一个 基准值（可以是待排序数组中任意一个数，一般为了方便就取数组从左往右数的第一个数）
3、根据选定的 基准值 对数组中的其他数进行遍历比较，小于等于基准数的放在基准数的左边，大于基准数的放在基准数的右边
4、这里的遍历不是从头到尾的遍历，而是用两个变量，分别代表从左往右 和 从右往左 的数组下标，依次往数组中心位置移动
5、先向前（从右往左）移动找到 小于等于 这个 基准值 的数，然后再向后（从左往右）找到 大于 这个 基准值 的数，然后将这个两个下标指向的数进行调换位置
6、在遍历寻找的过程中，一单两个下标相遇（指向同一个数），就可以结束遍历，将结束后将 基准值 填入到对应的位置
7、将分出来的基准数左边数组和基准数右边数组，分别再次进行上述的比较，知道左右两边的数组个数不足2个即为结束

快速排序思路 结果+代码：

结果：

代码：

var
  mArr: TArray<Integer>;
  a, i, j: Integer;
  mTempi: Integer;
begin
  GenerateRandomArray(mArr, 100, 5, True);
  Memo_Log.Lines.Add('============');
  ArrToMemo(mArr);

  // 数组的开始下标
  i := 0;
  // 数组的最后一位下标
  j := Length(mArr) - 1;
  a := mArr[i];
  Memo_Log.Lines.Add('本轮基准值=' + IntToStr(a));

 // 这里其实也需要判断一下数组的是否有2个及以上个数
  while j > i do
  begin
    // 首先从[j]开始向前（从右往左）找到一个 <= a 的数，将其放在[i]中
    while j > i do
    begin
      if mArr[j] <= a then
      begin
        mArr[i] := mArr[j];
        // 这里 i 进行 +1 是表示 mArr[i] 已经满足 <= a 本轮不用再次比较
        i := i + 1;
        ArrToMemo(mArr);
        Break;
      end;

      // 这里 j 进行 -1 是表示 mArr[j] 满足 > a 本轮不用再次比较
      j := j - 1;
    end;

    // 然后从[i]开始向后（从左往右）找到一个 > a 的数，将其放在[j]中
    while i < j do
    begin
      if mArr[i] > a then
      begin
        mArr[j] := mArr[i];
        // 这里 j 进行 -1 是表示 mArr[j] 已经满足 > a 本轮不用再次比较
        j := j - 1;
        ArrToMemo(mArr);
        Break;
      end;

      // 这里 i 进行 -1 是表示 mArr[i] 满足 <= a 本轮不用再次比较
      i := i + 1;
    end;

    // 上面的连个遍历就类似，找到一个 <= a 的数 和一个 > a 的数将它们进行调换位置，然后继续同上往中间找
    // 但其实写法是按照基准值提出来，作为一个空的坑位，然后有满足条件的就将这个数填入基准值的原始坑位，
    // 然后满足条件的那个原来的坑位又空出来了，就这样一直找一直填坑
  end;
  // 到这里出来的时候就是 i = j（相遇） 的时候，将基准值填入到空余的坑位
  mArr[i] := a;

  Memo_Log.Lines.Add('↓↓↓↓第一轮结果↓↓↓↓');
  ArrToMemo(mArr);

  // 这里是因为没有用递归，需要记录一下上一轮基准值最终坑位的下标，方便进行分开左右两边的数组
  mTempi := i;

  // 开始第二轮
  Memo_Log.Lines.Add('↓↓↓↓开始第二轮 左边的↓↓↓↓');

  // 第二轮左边数组开始的下标
  i := 0;
  // 第二轮左边数组结束的下标
  j := mTempi - 1;
  // 数组中个数不足2个不用排
  if j > i then
  begin
    a := mArr[i];
    Memo_Log.Lines.Add('本轮基准值=' + IntToStr(a));

    while j > i do
    begin
      // 首先从[j]开始向前（从右往左）找到一个 <= a 的数，将其放在[i]中
      while j > i do
      begin
        if mArr[j] <= a then
        begin
          mArr[i] := mArr[j];
          i := i + 1;
          ArrToMemo(mArr);
          Break;
        end;

        j := j - 1;
      end;

      // 然后从[i]开始向后（从左往右）找到一个 > a 的数，将其放在[j]中
      while i < j do
      begin
        if mArr[i] > a then
        begin
          mArr[j] := mArr[i];
          j := j - 1;
          ArrToMemo(mArr);
          Break;
        end;

        i := i + 1;
      end;
    end;
    // 到这里出来的时候就是 i = j 的时候
    mArr[i] := a;
    Memo_Log.Lines.Add('↓↓↓↓第二轮 左边的结果↓↓↓↓');
    ArrToMemo(mArr);
  end
  else
  begin
    Memo_Log.Lines.Add('第二轮 左边的数组长度不到2');
  end;


  // 开始第二轮
  Memo_Log.Lines.Add('↓↓↓↓开始第二轮 右边的↓↓↓↓');

  // 第二轮右边数组开始的下标
  i := mTempi + 1;
  // 第二轮右边数组结束的下标
  j := Length(mArr) - 1;
  if j > i then
  begin
    a := mArr[i];
    Memo_Log.Lines.Add('本轮基准值=' + IntToStr(a));

    while j > i do
    begin
      // 首先从[j]开始向前（从右往左）找到一个 <= a 的数，将其放在[i]中
      while j > i do
      begin
        if mArr[j] <= a then
        begin
          mArr[i] := mArr[j];
          i := i + 1;
          ArrToMemo(mArr);
          Break;
        end;

        j := j - 1;
      end;

      // 然后从[i]开始向后（从左往右）找到一个 > a 的数，将其放在[j]中
      while i < j do
      begin
        if mArr[i] > a then
        begin
          mArr[j] := mArr[i];
          j := j - 1;
          ArrToMemo(mArr);
          Break;
        end;

        i := i + 1;
      end;
    end;
    // 到这里出来的时候就是 i = j 的时候
    mArr[i] := a;
    Memo_Log.Lines.Add('↓↓↓↓第二轮 右边的结果↓↓↓↓');
    ArrToMemo(mArr);
  end
  else
  begin
    Memo_Log.Lines.Add('第二轮 右边的数组长度不到2');
  end;

  // ......按照这种情况循环，一直到左右两边的数不足2个结束
end;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

labview2018

exe 0星 超过10%的资源 755KB

下载

快速排序 结果+代码：

结果：

代码：

procedure TForm_Main.KuaiSuSort(var avArr: TArray<Integer>; avLeft, avRight: Integer);
var
  i, j, a: Integer;
begin
  if avLeft < avRight then
  begin
    a := avArr[avLeft];
    i := avLeft;
    j := avRight;

    while i < j do
    begin
      while j > i do
      begin
        if avArr[j] <= a then
        begin
          avArr[i] := avArr[j];
          i := i + 1;
          Break;
        end;

        j := j - 1;
      end;

      while i < j do
      begin
        if avArr[i] > a then
        begin
          avArr[j] := avArr[i];
          j := j - 1;
          Break;
        end;

        i := i + 1;
      end;
    end;
    avArr[i] := a;

    KuaiSuSort(avArr, avLeft, i - 1);
    KuaiSuSort(avArr, i + 1, avRight);
  end;
end;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

var
  mArr: TArray<Integer>;
begin
  GenerateRandomArray(mArr, 100, 10, True);
  Memo_Log.Lines.Add('排序前');
  ArrToMemo(mArr);

  KuaiSuSort(mArr, 0, Length(mArr) - 1);

  Memo_Log.Lines.Add('排序后');
  ArrToMemo(mArr);
end;
1
2
3
4
5
6
7
8
9
10
11
12

一点点笔记，以便以后翻阅。