递归算法流程图

A. 已知A[n]为整数数组，试写出实现下列运算的递归算法： (1) 求数组A中的最大整数。 (2) 求n个整数的和。

//递归求数组A[n]中的最大整数；
int maxintA(int n)
{
if(0 == n) return 0;//数组为空
if(1 == n) return a[n-1];//数组中只有一个元素

return (a[n-1] > manxintA(n-1)?a[n-1]:maxintA(n-1));//递归

}

//递归求素组A[n]中n个整数的和
int sumofA(int n)
{
if(0==n) return 0;// 数组为空
if(1==n) return a[n-1];// 数组中只有一个元素

return (a[n-1]+sumofA(n-1));//递归
}

B. java中递归算法是什么怎么算的

一、递归算法基本思路：

Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法表示问题的解。递归往往能给我们带来非常简洁非常直观的代码形式，从而使我们的编码大大简化，然而递归的思维确实跟我们的常规思维相逆的，通常都是从上而下的思维问题，而递归趋势从下往上的进行思维。

二、递归算法解决问题的特点：

【1】递归就是方法里调用自身。

【2】在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

【3】递归算法代码显得很简洁，但递归算法解题的运行效率较低。所以不提倡用递归设计程序。

【4】在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。

【5】在做递归算法的时候，一定把握出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口就是一个条件，当满足了这个条件的时候我们就不再递归了。

三、代码示例：

publicclassFactorial{

//thisisarecursivefunction

intfact(intn){

if(n==1)return1;

returnfact(n-1)*n;

}}

publicclassTestFactorial{publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Factorialfactorial=newFactorial();

System.out.println("factorial(5)="+factorial.fact(5));

}
}

代码执行流程图如下：

此程序中n=5就是程序的出口。

C. 二叉树先序遍历算法流程图怎么画，学的是数据结构c语言。

在计算机软件专业中，数据结构、以及 C 语言这两门课程是非常重要的两门课程。最为重要的是：如果将来想做计算机软件开发工作的话，那么对 C 语言中的指针编程、以及递归的概念是必须要熟练精通掌握的，因为它和数据结构课程中的链表、二叉树等内容的关系实在是太紧密了。但是这个编程技能必须要依靠自己多上机实践才能够真正彻底掌握的。
首先要搞明白二叉树的几种遍历方法：（1）、先序遍历法：根左右；（2）、中序遍历法：左根右；（3）、后序遍历法：左右根。其中根：表示根节点；左：表示左子树；右：表示右子树。
至于谈到如何画先序遍历的流程图，可以这样考虑：按照递归的算法进行遍历一棵二叉树。

程序首先访问根节点，如果根节点的值为空（NULL），则停止访问；如果根节点的值非空，则递归访问二叉树的左子树（left），然后是依然判断二叉树下面的左子树下面的根节点是否为空（NULL），如果根节点的值为空（NULL），则返回上一层，再访问二叉树的右子树（right）。依此类推。

D. c语言课程设计：选出一位幸运人士，一定要用递归算法！要源代码，流程图，和算法描述！

这道题做ACM题目的时候做过，当时使用数组做的，最后因为效率太低通过不了。

G Josephus Problem
Time Limit:1000MS Memory Limit:65535K

题型: 编程题 语言: 无限制

描述
Josephus Problem is an ancient problem named for Flavius Josephus. There are people standing in a circle waiting to be executed. The counting out begins at the
first point in the circle and proceeds around the circle in a fixed direction. In each step, one person is skipped and the next person is executed. The elimination
proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom.

For example, if there are 10 people in the circle, the executed order is 2, 4, 6, 8, 10, 3, 7, 1, 9. So the 5th person survives.

Now we define a function J(n) to be the survivor’s number when there are n person in the circle, and J^2(n)=J(J(n)), for instance J^2(10)=J(J(10))=J(5)=3,
and J^3(n)=J(J(J(n))), and so on. Could you calculate J^m(n)?

输入格式
The input consists of a number of cases.
Each case contains integers n and m. 0<n, m<=10^9
The input is terminated by a case with m=n=0

输出格式
For each case, print the number J^m(n)

输入样例
10 2
10 1
20 1
0 0

输出样例
3
5
9

Provider
admin
#include<stdio.h>
#include<malloc.h>
#include<math.h>

int J(int number,int * circle)

{
int i,length=number;

for(i=0;i<number;i++)
{
circle[i]=i+1;

}

while(length>1)
{
if(length%2==0)
{
for(i=0;i<length;i++)
{

circle[i]=circle[i*2];

}
length=length/2;
continue;

}
if(length%2==1)
{
circle[0]=circle[length-1];
for(i=1;i<length;i++)
{

circle[i]=circle[(i-1)*2];

}
length=length/2+1;
continue;

}

}

return circle[0];
}

int main()
{

int n,m,i,*circle;

circle=(int*)malloc(n*sizeof(int));
while(1){
{
scanf("%d%d",&n,&m);
}while(n<0||m<0||m>10);
if(n==0&&m==0)
break;
for(i=0;i<m;i++)
{
n=J(n,circle);

}
printf("%d\n",n);

}

return 0;
}

E. 请教遍历所有文件名（FileName）的流程图（请使用递归算法)

1、写出 查找子节点的方法 findchild（this node），参数是当前节点，开始是”filesystem“
2、查看当前节点的子节点 subnode = findchild （this node）
如果子节点不是 file，调用方法tempnode = findchild（sub node），直到找到子节点file
3、层层返回
filesystem --》 driver --》 dir --》 file
dir《 --
--》 file
--》 file
driver《--
filesystem 《--

F. 想要流程图

图的遍历

从图中某一顶点出发访遍图中其余顶点，且使每一顶点仅被访问一次。这一过程叫做图的遍历。
遍历图的基本方法有两种：深度优先搜索和广度优先搜索。这两种方法都适用于有向图和无向图。
和树的遍历类似，图的遍历也是从某个顶点出发，沿着，某条边搜索路径对图中所有顶点各作一次访问。若给定的图是连通图，则从图中任意顶点出发顺着边可以访问到该图中所有的顶点，然而，图的遍历比树的遍历复杂得多，这是因为图中的任一点都可能和其余顶点相邻接，故在访问了某个顶点之后，可能顺着某条回路又到了该顶点。为了避免重复访问同一个顶点，必须记住每个顶点是否被访问过。为此，可设置一个布尔向量visited[1..n],它的初值为false，一旦访问了顶点vi，便将visited[i]置为ture。

一、连通图的深度优先搜索
连通图深度优先搜索的基本思想如下：假定图中某个顶点v1为出发点，首先访问出发点v1，然后任选一个v1的访问过的邻接点v2，以v2为新的出发点继续进行深度优先搜索，直至图中所有顶点被访问过。
显然，图的深度优先搜索是一个递归过程，类似于树的前序遍历，它的特点是尽可能先对纵深方向进行搜索，故称之深度优先搜索。
现以图5-10中G为例说明深度优搜索过程。假定v1是出发点，首先访问v1。因v1有两个邻接点v2、v3均未被访问，选择v2作为新的出发点。访问v2之后，再找v2的未访问过的邻接点。同v2邻接的有v1、v4、v5，其中v1以被访问过，而v4、v5未被访问。选择v4作为新的出发点。重复上述搜索过程继续依次访问v8、v5。访问v5之后，由于与v5相邻的顶点均以被访问，搜索退回到v8。由于v8、v4、v2都没有未被访问的邻接点，所以搜索过程连续地从v8退回到v4，再退回到v2最后退回到v1这时选择v1的未被访问过的邻接点v3，继续往下搜索，依次访问v3、v6、v7，从而遍历了图中全部顶点。在这个过程中得到的顶点的访问序列：

(a)无向图G

(b)G的深度优先搜索过程
图5-10a 深度优先搜索过程示例

v1→v2→v4→v8→v5→v3→v6→v7
这样的序列就称之为图的深度优先搜索遍历序列。
连通图的深度优先搜索的非形式算法如下:
procere dfs (g:graph;v1:integer);
//从v1出发深度优先遍历图g//
begin write(v1);
visited[v1]:=ture;
找出g中v1的第一邻接点w;
while w存在do
[ if w 未被访问 then dfs(g,w);
w:=g中v1的下一邻接点]
end;
上述非行式算法未涉及图的存储结构.图的遍历过程必然地包含对图中每个顶点查找其邻接点这一操作;而在图的不同存储结构上查找邻接点的方法是不同的.
若以邻接表为存储结构,查找邻接点操作实际上是顺序查找链表.邻接表上的深度优先算法如下:
procere dfs(g:adj_list;v1:integer);
//从v1出发深度优先遍历图g.g以邻接表为存储结构//
begin write(v1);
visited[v1]:=ture;//标志v1已访问//
p=g[v1].link;//找v1的第一个邻接点//
while p<>nil do
[ if not (visited[p↑.adjvex]);//书错写成vertex//
then dfs(g,p↑.adjvex);
p:=p↑.next]//回溯----找v1的下一个邻接点//
end;

二、连通图的广度优先搜索
连通图广度优先搜索的基本思想是：从图中某个顶点v1出发，访问了v1之后依次访问v1的所有邻接点；然后分别从这些邻接点出发按深度优先搜索遍历图的其它顶点，直至所有顶点都被访问到。它类似于树的按层次遍历，其特点是尽可能优先对横向搜索，故称之为广度优先搜索。
下面以图5-10中G为例说明广度优先搜索的过程。首先从起点v1出发，访问v1。v1有两个未曾访问的邻接点v2和v3。先访问v2，再访问v3。然后再先后访问v2的未曾访问过的邻接点v4、v5及v3的未曾访问过的邻接点v6、v7。最后访问v4的未曾访问过的邻接点v8。至此图中所有顶点均以被访问到。得到的顶点访问序列为：

(a)无向图G

(b)G的广度优先搜索过程
图5-10b 广度优先搜索过程示例

v1→v2→v3→v4→v5→v6→v7→v8
相应的，这样的序列就称之为图的广度优先搜索遍历序列。
在广度优先搜索中，若对x的访问先于y，则对x邻接点的访问也先于队y的邻接点的访问。因此，可采用队列来暂存那些刚访问过，但可能还有为访问过的邻接点的顶点。
连通图的广度优先搜索算法如下：
procere bfs(g:adj_list;v1:integer);//书错写成adjlist//
//以邻接表为存储结构的广度优先搜索。Q为队列，假定visited的各分量已只置 为false//
begin init_linkedque(Q);//设计一个空队Q//
visited[v1]:=ture;write(v1);
in_limkedque(Q,v1); //v1入队//
while not empty(Q) do
[ v:=out_linkedque(Q);
p:=adj_list[v].link;//书错写成adjlist//
while p<>nil do
[ if visited[p↑.adjvex]:=false;//书错写成vertex//
then
[visited[p↑.adjvex]:=ture;
with(p↑.adjvex);
in_linkedque(Q,p↑.adjvex);]
p:=p↑.next]]
end;

三、图的连通分量计算
如果要遍历一个非连通图，则需要多次调用dfs或bfs，每一次都要得到一个连通分量；调用dfs或bfs的次数就是连通分量的个数。因此很容易写出非连通图的遍历算法和计算一个图的连通分量得算法。下面给出的是以邻接表为存储结构，通过调用深度优先搜索算法实现的计算连通分量的算法。
procee conn_component (var g:graph;
var visited:array[1..vnum);
begin for v:=1 to vnum do
visited[v]:flase;
count:=0;
for v:=1 to vnum do
if not(visited[v])then
[count:=count+1;
write('component',count,':');
dfs(g,v);writeln;]
end;
对于图5-5中非连通图G3，用上述算法可求出3个连通分量，各连通分量所含顶点如下：
component1: 1 2 3
component2: 4 5 6 7
component3: 8 9
注意，若从上述算法中删去有关连通分量计数器的操作，就得到一个非连通图德遍历算法。

详细资料和图片请参看参考资料，那里的比较详细

G. 递归算法流程图如何画请以菲波那切数列递归算法为例

递归（recursion）：程序调用自身的编程技巧。
递归满足2个条件：
1）有反复执行的过程（调用自身）
2）有跳出反复执行过程的条件（递归出口）

递归例子：
（1）阶乘
n! = n * (n-1) * (n-2) * ...* 1(n>0)
//阶乘
int recursive(int i)
{
int sum = 0;
if (0 == i)
return (1);
else
sum = i * recursive(i-1);
return sum;
}

（2）河内塔问题

//河内塔
void hanoi(int n,int p1,int p2,int p3)
{
if(1==n)
cout<<"盘子从"<<p1<<"移到"<<p3<<endl;
else
{
hanoi(n-1,p1,p3,p2);
cout<<"盘子从"<<p1<<"移到"<<p3<<endl;
hanoi(n-1,p2,p1,p3);
}
}

（3）全排列
从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。
如1,2,3三个元素的全排列为：
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1
//全排列
inline void Swap(int &a,int &b)
{
int temp=a;
a=b;
b=temp;
}
void Perm(int list[],int k,int m)
{
if (k == m-1)
{
for(int i=0;i<m;i++)
{
printf("%d",list[i]);
}
printf("n");
}
else
{
for(int i=k;i<m;i++)
{
Swap(list[k],list[i]);
Perm(list,k+1,m);
Swap(list[k],list[i]);
}
}
}

H. 给定以下XML文件，完成算法流程图

void FindFile( Directory d ) { FileOrFolders = d.GetFileOrFolders(); foreach( FileOrFolder fof in FileOrFolders ) { if( fof is File ) You Found a file; else if ( fof is Directory ) FindFile( fof ); } }

I. 汉诺塔问题的递归算法流程图

关键是第一步移法，奇数层的说，3层在第一柱，后两根柱数数：123。所以，第一块应放在第二根柱，4层，第一块放第三柱。...........奇数层第一块放第二柱，偶数层第一块放第三柱。

J. 按要求设计递归算法。只需写出伪代码或画流程图，不需语言实现，但算法必须完整清晰。

arrs[100000][100000];
a[100000];
f(i,){
if(i==4){
arrs[]=a;
return;
}
a[i]=;
f(i+1,+3);
f(i+1,+4);
}
f(0,0)
arrs就是结果，并且是排了序的。