谁能讲讲递归(300分)

小弟学习中一直对这个概念比较模糊，不会使用。有没有高人用通俗的语言讲解一下，最好能用例子。拜托了 分数300分。参与有奖。盼望您的讲解。

我自己顶一下,很多时候我都不知道用递归涵数可以解决问题,这是为什么.

递归.简单说就是自己调用自己,当满足一定条件终止
如:
func(int x)
{
if (x > 2)
resul:=func(x - 1) + func(x - 2);
else

result:=0;
}

谢谢您,您说的不错,能不能从实际编程中讲讲,在那些实际的例子中能用到.

个人观点:相同操作,范围大->小

删除一个非空目录，就要用到递归。这个论坛以前有很多，这里不浪费空間了

以前有能否给个连接。我这里搜索 老出问题。

上论坛不如看书。

递归在编程过程中的理解就是自己调用自己
在底层原理上递归是通过栈实现的
每次自己调用自己时，将递归相关的上下文变量状态入栈
调用结束返回上层时将上一层的上下文变量状态出栈并根据根据一定的条件赋值
给一个计算阶乘的代码例子
function getFactorial(n:int64):int64;
begin
if n<0 then
result:=0
else
if n<=2 then
result:=n
else
result:=n*getFactorial(n-1);
end;
当调用getFactorial(3)时
执行到result:=n*getFactorial(n-1);
会先将n=3入栈
然后执行getFactorial(2);
结果是2
这时取出刚才入栈的3与2相乘
得到结果6

这么多分，蹭分
我个人看法：中学的数学归纳法 的证明方法 有没有 印象？递归就是这个方法的应用，虽然顺序是反过来的。
简单的举个例子：
求阶乘：X=n!
顺序的做法：
X0=1
X1=1*1
X2=2*X1
X3=3*X2
X4=4*X3
....
Xn=(n-1)* Xn-1
递归的做法：
求 Xn=n!
Xn=n * Xn-1 (这时候 Xn-1未知，那么调用下面求出来)
Xn-1= (n-1)* Xn-2 (这时候 Xn-2未知，那么调用下面求出来)
Xn-2= (n-1)* Xn-3 (这时候 Xn-3未知，那么调用下面求出来)
....
X0 =1 (到这里，有个确定的答案了)
在最后一行有答案后，前面已经有n层等待这个答案了，递归的作用就是能实现把这个答案一层一层地往上传递。
个人看法
优点是：程序短；如果读懂了就容易理解（毕竟程序比别人短很多）
缺点是：堆栈占用太频繁；如果读不懂程序就不好理解；分支多情形不好处理。
而平时在编程里面，我尽量不用这个，维护太伤脑筋了，顺的不用，非得用反过来的？

//一个通用的递归遍历Tree的方法:
//先声明一个方法指针类型
type
TDealNodeEvent = procedure(ANode: TTreeNode) of object;
procedure RecurseTree(ANode: TTreeNode;
ANodeFunc: TDealNodeEvent);
var
I: Integer;
begin
if ANodeFunc = nil then
raise Exception.Create('请指定Tree的节点处理方法');
ANodeFunc(ANode);
for I := 0 to ANode.Count - 1do
RecurseTree(ANode.Items, ANodeFunc);
end;

//调用
procedure TForm1.DealWithNode(ANode: TTreeNode);
begin
//Your Code for each node.
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
//对第一个NODE及其子节点处理
RecurseTree(TreeView1.Items[0], DealWithNode);
end;

俺来泼瓢冷水：
1、递归不是高科技...
2、绝大部分的递归都可以转化为循环，更何况递归有深度限制...
3、递归要占用专用的栈，不是说你写了递归电脑就认识它是递归了，编译程序要对递归进行甄别...
4、频繁的压栈和出栈，导致效率要远低于循环，所以能用循环就不要用递归...
5、对那些绞尽脑汁往递归上靠的人说一句：纯粹吃饱了撑的，这个世界因你而白痴！谢谢！

一般使用递归的条件是：
对于同样的一种操作，其结果会成为下一次操作的传入参数
所有的递归都可以转化成循环：
while nowobj<>nildo
begin
do
(nowobj);
{当前对象进行的操作}
if getchild(nowobj)<>nil then
{获取当前对象的下级对象}
nowobj:=getchild(nowobj) {如果存在下级对象则改为指向下级对象}
else
if getnext(nowobj)<>nil then
{如果没有则获取下一个同级对象}
nowobj:=getnext(nowobj) {如果下个同级对象存在则指向下个同级对象}
else
nowobj:=getnext(getparent(nowobj));
{如果下个同级对象不存在则该为指向父对象}
end;

总的来说：
用递归使程序代码比较容易被理解，但是如果递归层次太多效率比较低
转化成循环后会麻烦点，可能回需要纪录很多状态信息，效率可能比较高，但是代码不好理解

这里有个例子
http://www.delphibbs.com/delphibbs/dispq.asp?lid=3889804

递归用在游戏最多.
如:扫雷,星际,罗马....
主要是找到最近路径,递归一步步往前走,有障碍物绕道到终点

嘿嘿，免費學了好多東西

递归就是用内存空间换难度
只有尾递归才能转换成不占内存的循环语句。
总之能用递归就要用，除特别要求速度。
递归的速度也不慢，比循环要慢一点点。

[][]
{
从前有座山，山里有个庙，庙里有个和尚讲故事，讲的什么呢？
{
从前有座山，山里有个庙，庙里有个和尚讲故事，讲的什么呢？
{
从前有座山，山里有个庙，庙里有个和尚讲故事....
}
}
}

简单的说就是函数调用自身。。
functin A()
begin
......
if () then
A;
.....

end;

procedure TForm1.CreateTree;
procedure CreateTree(Pre:string;preNode:TTreeNode);
var
pInfoTNodeInfo;
node:TTreeNode;
sql:string;
Query:TADOQUery;
begin
Query:=TADOQuery.Create(nil);
Query.ConnectionString:='Provider=SQLOLEDB.1;Persist Security Info=False;User ID=sa;Initial Catalog=PeaqeNet9001;Data Source=.';
sql:= Format('Select * from V_Domain where UPId=%s', [QuotedStr(pre)]);
Query.Close;
Query.SQL.Clear;
Query.SQL.Add(sql);
Query.Open;
Query.First;
while not Query.Eofdo
begin
new(pInfo);
pInfo.preId:=Query.Fields[0].AsString;
pInfo.id:=Query.Fields[4].AsString;
If (pInfo.id=pInfo.preId)then
begin
node:=tree.Items.AddChild(preNode,pInfo.id);
node.Data:=pInfo;
node.OverlayIndex:=2;
Query.Next;
//CreateTree(pInfo.id,node);
// Query.Next;
end
else
//If pInfo.id<> pInfo.preId then
begin
node:=tree.Items.AddChild(preNode,pInfo.id);
node.Data:=pInfo;
node.ImageIndex:=1;
Node.SelectedIndex:=2;
//node.OverlayIndex:=2;
//node.StateIndex:=1;
CreateTree(pInfo.id,node);
Query.Next;
end;
//Query.Next;
end;
Query.Close;
Query.Free;
end;
begin
createTree('1',nil);
tree.FullExpand;
end;