各种递归算法化简（化复杂)的方法和案例

本文总结了各种递归算法化简（化复杂)的方法和案例

 

1.简单例子 计算阶乘

function frac(avalue:Integer):Integer;
begin
  if avalue=1 then Result:=1
  else
  Result := avalue * frac(avalue-1);
end;

特点：计算可以无序

方法：可将需要计算的数字全部放到一个队列或者栈中

type
  PTA = ^TA;
   TA=record
    b:Integer;
  end;

function frac(avalue:Integer):Integer;
var  c:integer;
   b:PTA;
   s,i:integer;
     Q:tqueue;
begin
  Q:=TQueue.Create;
 for I:= 1 to avalue do
  begin
    b := new(pTA);
    b^.b:=I;
    Q.Push(b);
  end;

  s:=1;

  for I:= 0 to Q.count-1 do
  begin
    b:=Q.Pop();
    s:=s*b^.b;
  end;
  Q.Free;
  Result := s;
end;

2.目录搜索

//=========递归文件搜索

procedure search(dir: string; var dirlines: TStringlist);
var
  sr: TsearchRec;
begin

  if findfirst(dir + '*.*', faanyfile, sr) = 0 then
  begin
    repeat
      if (sr.name <> '.') and (sr.name <> '..') then
      begin
        if (filegetattr(dir + sr.name) and fadirectory) <> fadirectory then
        begin
          dirlines.Add(dir + sr.name);
        end
        else search(dir + sr.name + '\', dirlines); {递归调用}
      end
    until findnext(sr) <> 0;
  end;

end;
特点:搜索可以无序

方法：将所有目录放到队列，第二次再处理队列，由于队列会在搜索中增加和减少，从儿避免递归

//=========非递归文件搜索
type PTA=^TA;
     TA=record
       dir:string[255];
     end;

var  Q:TQueue;

procedure search2(dir:string;var dirlines:TStringList);
var  sr: TsearchRec;
  b:PTa;
  i:integer;
begin
  if findfirst(dir + '*.*', faanyfile, sr) = 0 then
  begin
    repeat
      if (sr.name <> '.') and (sr.name <> '..') then
      begin
        if (filegetattr(dir + sr.name) and fadirectory) <> fadirectory then
        begin
          dirlines.Add(dir + sr.name);
        end
        else
        begin
          b:=new(PTA);
          b^.dir :=dir + sr.name+'\';
          Q.push(b);
        end;
      end
    until findnext(sr) <> 0;
  end;

end;

procedure search(dir: string; var dirlines: TStringlist);
var
  sr: TsearchRec;
  b:PTa;
  i:integer;
begin
  Q:=TQueue.create;
  search2(dir,dirlines);

  for I:= 0 to Q.count() -1 do
  begin
    b:=Q.Pop();
    search2(b.dir,dirlines);
  end;
  Q.free;

end;

3.快速排序

 //=========递归快速排序

procedure QSort(var A: array of Integer);
  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];
    repeat
      while A[Lo] < Mid do
        Inc(Lo);
      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);
    if Lo < iHi then
      QuickSort(A, Lo, iHi);
  end;
begin
  QuickSort(A, Low(A), High(A));
end;

特点：计算需要顺序，所以只能模拟栈

// 无递归的快速排序
procedure QuickSortNoRecurse(var abc: array of Integer);
  procedure QSNR(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
    Stack: array [0 .. 63] of Integer; { allows for 2 billion items }
    SP:    Integer;
  begin
    Stack[0] := aFirst;
    Stack[1] := aLast;
    SP       := 2;
    while (SP <> 0) do
    begin
      dec(SP, 2);
      aFirst := Stack[SP];
      aLast  := Stack[SP + 1];
      while (aFirst < aLast) do
      begin
        Pivot := abc[(aFirst + aLast) div 2];
        L     := pred(aFirst);
        R     := succ(aLast);
        while true do
        begin
          repeat
            dec(R);
          until (abc[R] <= Pivot);
          repeat
            inc(L);
          until (abc[L] >= Pivot);
          if (L >= R) then
            Break;
          Temp   := abc[L];
          abc[L] := abc[R];
          abc[R] := Temp;
        end;
        if (R - aFirst) < (aLast - R) then
        begin
          Stack[SP]     := succ(R);
          Stack[SP + 1] := aLast;
          inc(SP, 2);
          aLast := R;
        end
        else
        begin
          Stack[SP]     := aFirst;
          Stack[SP + 1] := R;
          inc(SP, 2);
          aFirst := succ(R);
        end;
      end;
    end;
  end;

begin
  QSNR(abc, 0, High(abc));
end;
这个算法来自网络。

下载源码

转载于:https://www.cnblogs.com/stevenlaz/p/4637809.html