各种递归算法化简(化复杂)的方法和案例
本文总结了各种递归算法化简(化复杂)的方法和案例
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;
这个算法来自网络。