排序法

1、快速排序法（这个最容易迷惑）{=====================================================================

函数名：QuickSort

作者：pyg

日期：2000-01-01

功能：快速排序法

输入参数：A 待排序数组；iLo 数组最小下标；iHi：数组最大下标

返回值：无

修改记录：2008-07-01

=====================================================================}

procedure QuickSort(var A: array of Integer; iLo, iHi: Integer);

var

  Lo, Hi, Mid, T: Integer;

begin

  Lo := iLo;

  Hi := iHi;

  Mid := A[(Lo + Hi) div 2];  //数组中间位置的值，注意A下标从0开始计算

  repeat

    //如果左边的A[Lo]小于中间值则此值不动下标+1，直到找到大于或等于中间值，用于与右边的调换

    while A[Lo] < Mid do Inc(Lo);

    //如果左边的A[Hi]大于中间值则此值不动，下标-1，直到找到小于或等于中间值，用于与左边的调换

    while A[Hi] > Mid 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);

  {递归对做右部分进行再次排序（此时的Lo，iHi值为第一轮排序结束的值，不会因为左半部分的再次排序而改变

  ，因为递归调用时，所传的变量为函数内部的变量}

  if Lo < iHi then QuickSort(A, Lo, iHi);

end;

2、冒泡排序法（2种接口）

procedure BubbleSort(var Num: TArray; NumSize: Integer);

var

  pass, I, Tmp, NumTmp: Integer;

begin

  //1.for实现

  for pass := 1 to NumSize - 1 do

  begin

    Tmp := NumSize - pass;

    for I := 0 to Tmp - 1 do

    begin

      if Num[I] > Num[I + 1] then

      begin

        NumTmp := Num[I];

        Num[I] := Num[I + 1];

        Num[I + 1] := NumTmp;

      end;

    end;

  end;   

  //2.while实现

{  pass := 1;

  I := 0;

  SetLength(Num, NumSize);

  while pass < NumSize do //共进行NumSize - 1 轮

  begin

    Tmp := NumSize - pass;

    while I < Tmp do     //比较一轮

    begin

      if Num[I] > Num[I + 1] then

      begin

        NumTmp := Num[I];

        Num[I] := Num[I + 1];

        Num[I + 1] := NumTmp;

      end;

      Inc(I);

    end;

    Inc(pass);

  end;  }

end;

procedure BubbleSort2(var SortArray: array of Integer);

var

  I, J, Tmp: Integer;

begin

  for I := High(SortArray) downto Low(SortArray) do

  begin

    for J := Low(SortArray) to High(SortArray) - 1 do

    begin

      if SortArray[J] > SortArray[J + 1] then

      begin

        Tmp := SortArray[J];

        SortArray[J] := SortArray[J + 1];

        SortArray[J + 1] := Tmp;

      end;

    end;

  end;

end;

3、插入排序法（两种接口）

procedure InsertSort(var Num: TArray; NumSize: Integer);

var

  Inserter, Index, I: Integer;

begin

  for I := 1 to NumSize - 1 do   //共执行NumSize - 1轮

  begin

    Inserter := Num[I];

    Index := I - 1;

    while (Index >= 0) and (Inserter < Num[Index]) do //寻找插入点

    begin

      Num[Index + 1] := Num[Index]; //后挪一个位置

      Index := Index - 1;

    end;

    Num[Index + 1] := Inserter;  //插入

  end;

end;

procedure InsertSort2(var Num: Array of Integer);

var

  Inserter, Index, I: Integer;

begin

  for I := Low(Num) + 1 to High(Num) do

  begin

    Inserter := Num[I];

    Index := I - 1;

    while (Index >= 0) and (Inserter < Num[Index]) do

    begin

      Num[Index + 1] := Num[Index];

      Index := Index - 1;

    end;

    Num[Index + 1] := Inserter;    

  end;

end;

4、判断素数（附加一个，呵呵，面试总整出这个）

function IsPrime(aNum: Integer): Boolean;

var

  I, Tmp: Integer;

begin

  Result := True;

  if aNum <= 1 then

  begin

    Result := False;

    exit;

  end;

  Tmp := Trunc(Sqrt(aNum));

  //1.for实现  

  for I := 2 to Tmp do

  begin

    if aNum mod I = 0 then

    begin

      Result := False;

      break;

    end;

  end;

  //2.while 实现

  {I := 2;

  while I <= Tmp do

  begin

    if aNum mod I = 0 then

    begin

      Result := False;

      Break;

    end;

    Inc(I);

  end; }

end;