Delphi 数组排序

在Delphi中，可以使用内置的TArray.Sort方法对数组进行排序。以下是一个简单的示例，对一个整型数组进行从小到大的排序：

var
  arr: array of Integer;
  i: Integer;
begin
  // 初始化数组
  SetLength(arr, 5);
  arr[0] := 3;
  arr[1] := 1;
  arr[2] := 4;
  arr[3] := 2;
  arr[4] := 5;
  
  // 排序数组
  TArray.Sort<Integer>(arr);
  
  // 输出排序后的数组
  for i := Low(arr) to High(arr) do
    WriteLn(arr[i]);
end;

以上示例中，首先使用SetLength函数初始化一个包含5个整型元素的数组arr，然后使用TArray.Sort方法将数组从小到大排序，最后使用for循环输出排序后的数组。需要注意的是，TArray.Sort方法需要指定数组元素的类型，上述示例中为Integer。如果需要对其他类型的数组进行排序，只需要将泛型参数改为相应的类型即可。

相关问题

delphi 冒泡排序

以下是 Delphi 冒泡排序的示例代码：

program BubbleSort;

{$APPTYPE CONSOLE}

uses
  SysUtils;

const
  MaxArraySize = 100;

type
  TArray = array[1..MaxArraySize] of Integer;

var
  A: TArray;
  N: Integer;

procedure ReadData;
var
  I: Integer;
begin
  Write('Enter the size of the array (1-100): ');
  ReadLn(N);
  if (N < 1) or (N > MaxArraySize) then
    raise Exception.Create('Invalid array size');
  for I := 1 to N do
  begin
    Write('Enter element ', I, ': ');
    ReadLn(A[I]);
  end;
end;

procedure BubbleSort(var A: TArray; N: Integer);
var
  I, J, Temp: Integer;
begin
  for I := N downto 2 do
    for J := 1 to I - 1 do
      if A[J] > A[J + 1] then
      begin
        Temp := A[J];
        A[J] := A[J + 1];
        A[J + 1] := Temp;
      end;
end;

procedure WriteData;
var
  I: Integer;
begin
  WriteLn('Sorted array:');
  for I := 1 to N do
    WriteLn(A[I]);
end;

begin
  try
    ReadData;
    BubbleSort(A, N);
    WriteData;
  except
    on E: Exception do
      WriteLn(E.Message);
  end;
end.

该程序首先从用户处读取一个整数数组，然后使用冒泡排序算法对其进行排序，最后将排序后的数组打印到控制台上。冒泡排序算法的核心代码位于 `BubbleSort` 过程中，其中使用两个嵌套的循环来比较相邻的元素并进行交换，以便将最大的元素逐渐“冒泡”到数组的末端。

delphi 排序算法

Delphi 提供了多种排序算法，包括冒泡排序、选择排序、插入排序、快速排序等。下面是一个快速排序的示例代码：

procedure QuickSort(var A: array of Integer; iLo, iHi: Integer);
var
  Lo, Hi, Pivot, T: Integer;
begin
  Lo := iLo;
  Hi := iHi;
  Pivot := A[(Lo + Hi) div 2];
  repeat
    while A[Lo] < Pivot do Inc(Lo);
    while A[Hi] > Pivot do Dec(Hi);
    if Lo <= Hi then
    begin
      T := A[Lo];
      A[Lo] := A[Hi];
      A[Hi] := T;
      Inc(Lo);
      Dec(Hi);
    end;
  until Lo > Hi;
  if Hi > iLo then QuickSort(A, iLo, Hi);
  if Lo < iHi then QuickSort(A, Lo, iHi);
end;

这个算法使用递归的方式进行排序，从数组的中间选取一个元素作为枢轴值，将小于枢轴值的元素放在枢轴值的左边，大于枢轴值的元素放在右边，然后对左右两个子数组分别进行排序。时间复杂度为 O(n log n)。