c語言中的函數遞歸調用函數

A. c語言中自定義函數中遞歸調用是怎樣工作的

假如輸入3
y=ff(n);
//第一次調用
執行else
f=ff(n-1)*n;
//f=ff2*3
ff2遞歸
執行else
f=ff(n-1)*n;
//f=ff1*2
ff1遞歸
執行else
if(n==0||n==1)
f=1;
f=1
跳過else
f=ff(n-1)*n;
//兩個else並列的不再執行第二個
執行return(f);
從printf("%d!=%ld",n,y);向下執行主程序

B. C語言函數遞歸調用問題

函數其實沒有釋放內存的概念，因為函數都是在指令區，而不是通常所說的釋放內存對應的數據區，不過在整個程序執行完之後指令區也是要釋放的。
函數調用的大概過程如下：
1，將調用函數的上下文入棧；
2，調用被調用函數；
3，被調換函數執行；
4，調用函數上下文出棧，繼續執行後繼指令。
所以在函數調用過程中原調用函數是不會退出的-----即你所說的釋放內存。
具體到你給的代碼：
首先main中調用test，
進入test後要求讀入一個char，
你輸入'1'後執行case
'1'中語句，所以輸出「已調用」，然後就執行test()語句，即遞歸調用，此時main調用的test要等新的test執行完畢才能繼續執行後繼的i++語句；
再次進入test之後與從main中進入時一樣，如果輸入的是'1'會接著遞歸調用test，由於你輸入了5次1，所以會繼續調用5次test；
在最後一個test中你輸入了ESC?
所以不再走case
'1'而走default了，所以輸出"222222";
switch執行完之後判斷c==27滿足，所以while循環退出，繼續執行printf語句，由於之前的test統統沒有執行過case
1里的i++語句，所以全局變數i還是0；輸出i=0；
到此最後一次test執行完畢；
倒數第二次的test繼續執行i++，
所以i=2了，case
1執行完畢，但由於沒有寫break語句，所以繼續執行default
語句，輸出"222222",
退出switch語句，判斷c==27，
由於c是全局變數，且最後一次輸入的剛好是ESC,
所以判斷滿足，
退出while循環，輸出i=1,
到此倒數第二次test執行完畢；
與倒數第二次類似的繼續執行倒數第三、倒數第四、倒數第五和最終的第一次test後繼代碼，也就輸出如你列出的結果了。

C. c語言關於函數的遞歸調用問題

一般來說是自己調用自己，一般有兩個分支，一個分支是調用自己，還有一個分支是結束條件如求n! int f(int n) { if(n==1) //這個是結束條件 return 1; else //這個是調用自己的分支 return n*f(n-1); } 還有一個比較復雜一點，是雙向調用，也就是a函數調用b函數，b函數在調用a函數這樣循環調用，其實基於這個道理，還有多個函數互相調用，不過這樣的情況很少見但萬變不離其宗，每個函數都有兩個分支，一個是結束條件，一個是調用函數

D. c語言 函數遞歸調用

這個很好理解啊，你看看你輸入的參數什麼就可以了。
你函數的聲明是void fuck ( int n ,char o, char t, char th)
第一次調用你是fuck ( n, 'A','B','C');這時，o=A,t=B,th=C,所以輸入
printf ("%c %c %c\n",t,o,th);就是BAC，
然後你fuck(n-1,t,o,th);，這時o=原來的t=B,t=原來的o=A,th=C，輸出
printf ("%c %c %c\n",t,o,th);就是ABC了如此類推

E. c語言函數的遞歸調用

遞歸必須滿足兩個條件：1.初始條件；2.遞歸函數.舉個例子，求階乘：有f(1)=1;f(n)=n*f(n-1)(n≥2)現在你可以實現如下：long func(int n)//定義函數
{
long f,s=0;
if(n==1)f=1;
else
{
f=func(n-1)*n; //這里就是一個遞歸的過程，自身調用自身
s=s+f;
}
return s;
} 假設你現在是求3！執行過程就是：f(3)=f(2)*3;然後調用自身：f(2)=f(1)*2;在調用遇到初始條件：f(1)=1;則f(3)=1*2*3=6

F. c語言函數遞歸調用

我給你舉個簡單的例子你就明白了，你可以假設n=3
然後代入這個函數，a(3)=a(2)+5;而a(2)=a(1)+5;a(1)=1
所以最後就是a(3)=1+5+5=11…
同理你可以算出a(10)=1+5*9=46

滿意請採納

G. c語言函數遞歸調用

#include int Func(int n) { if(n < 2) return 1; else return n*Func(n-1); } int main() { int n = 5; printf("n! = %d\n",Func(n)); return 0; } 執行過程：－》Func(5) －》5*Func(4) －》5*(4*Func(3)) －》5*(4*(3*Func(2)))) －》5*(4*(3*(2*Func(1)))) 當n為0的時候停止遞歸，返回結果由於遇到1的時候返回1，那麼Func(1)=1 所以結果是5*(4*(3*(2*1))) ＝ 120

H. C語言，函數遞歸的調用

#include"stdio.h"
voidfun1(intn,intm){
	if(m>0)
		fun1(n,m-1);
	printf("%-2d+%2d=%-2d",n,m,n+m);
}
voidfun2(intn,intm){
	if(n>0)
		fun2(n-1,m);
	fun1(n,m-n);
	printf("
");
}
intmain(intargv,char*argc[]){
	intN;
	printf("InputN(int0<=N<=99)...
N=");
	if(scanf("%d",&N)!=1||N<0||N>99){
		printf("Inputerror,exit...
");
		return0;
	}
	fun2(N,N);
	return0;
}

運行樣例：

I. c語言遞歸函數，調用過程

從主函數fun(6,&x)開始調用。調用的時候，實參6和&x將自身的值傳遞給形參n,s,接著，開始執行fun函數體內的語句第一次調用：判斷if(n==0||n==1)，此時的n值為6，不滿足條件，執行else部分語句。 fun(n-1,&f1);fun(n-2,&f2);先調用fun(n-1,&f1);而fun(n-2,&f2);需要當fun(n-1,&f1);符合if條件以後才輪到它執行第二次調用：此時，形參n=6轉變為實參n,fun（n-1,&f1）等價於fun(5,&f1),繼續判斷，if(n==0||n==1)，又不滿足條件，於是，重復之前的操作，轉向else部分執行。 fun(n-1,&f1);fun(n-2,&f2);此時的n=5,同樣是先調用fun(n-1,&f1);後面那個fun(n-2,&f2);同樣處於等待狀態，等待前面的 fun(n-1,&f1);符合IF條件後才輪到它執行，於是，fun(n-1,&f1);就這樣一層一層執行下去，每執行一次，n的值減一,當n=1的時候，執行if部分，這時，便可以在fun(n-1,&f1);執行完畢只有繼續執行fun(n-2,&f2);，接著，返回前一次調用的狀態，開始執行fun(n-2,&f2);比如當n=2的時候，執行完fun(2-1=1,&f1)以後，便開始執行fun(2-2=0,&f2);和它後面的語句，最終，函數返回上一次調用的狀態，即fun(3,&f1);此時，fun(3,&f1)已經執行完畢，因為之前我們已經把fun(2,&f1)執行完了，接著，應該執行的是fun(3-2=1,&f2);當這個函數最後終也符合if部分要求，又返回到前面的fun(4,&f1),執行完後，開始執行fun(4,&f2)，這樣一個流程。通常來說，遞歸可以簡化代碼，但同時也會增加系統開銷並且讓程序閱讀的時候要比正常的順序程序難以理解一些。不過，現代的硬體飛速發展，用遞歸是完全可以的。

J. c語言函數的遞歸調用

遞歸有一個堆棧的概念，那就意味著他是一個反理解的過程：就象數學遞推一樣，你知道第一項，第二項，又知道通項公式，那你就可以知道任何一項。
然後你看代碼：fun(0)==0,fun(1)==1;是告訴你一二項。
fun(n)==fun(n-1)+fun(n-2);是告訴你通項公式。那麼，你就可以知道任何一項。你這樣理解就差不多了，具體機器是怎麼操作的，那很復雜的，也不需要明白！！！！