189 8069 5689
能力有限，仅知几点
在佛山等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站设计、成都网站建设 网站设计制作定制网站设计,公司网站建设,企业网站建设,成都品牌网站建设,营销型网站建设,成都外贸网站建设公司,佛山网站建设费用合理。
两者都是重复某一操作直到满足条件为止。
不同之处在于，递归是函数调用自身，而迭代是使用循环。
某些情况下递归更加简单，可读性更高，而用循环则十分复杂。如二分法，快速排序等。
递归很容易导致栈溢出，导致程序崩溃，而循环不会。
综上所述，能用循环用循环，递归是万不得已的手段。
递归好处：代码更简洁清晰，可读性更好
递归可读性好这一点，对于初学者可能会反对。实际上递归的代码更清晰，但是从学习的角度要理解递归真正发生的什么，是如何调用的，调用层次和路线，调用堆栈中保存了什么，可能是不容易。但是不可否认递归的代码更简洁。一般来说，一个人可能很容易的写出前中后序的二叉树遍历的递归算法，要写出相应的非递归算法就比较考验水平了，恐怕至少一半的人搞不定。所以说递归代码更简洁明了。
递归坏处：由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，可能系统撑不住。
1、递归就是函数调用函数本身，运行起来就是函数嵌套函数，层层嵌套，所以函数调用、参数堆栈都是不小的开销，但是程序简单。
2、非递归就是不断地对参数入栈、出栈，省去了函数层层展开、层层调用的开销。虽然参数出入栈次数多了，但是一般都开辟固定的足够大的内存来一次性开辟、重复使用。
3、非递归是从堆栈的角度来编写程序，速度快，但代码复杂。
递归是从问题本身的逻辑角度来编写，虽然速度相对慢，但代码容易理解。
如果对速度要求不高，建议用递归方式。
4、摘录例子如下：
#include stdio.h
#include stdlib.h
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;//二叉树的节点类型
typedef struct QNode
{
BiTNode data;
struct QNode *next;
} QNode,*QueuePtr;//队列节点类型
typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;//队列的头尾指针
void InitQueue(LinkQueue *Q)//创建队列
{
Q-front=Q-rear=(QueuePtr)malloc(sizeof(QNode));
Q-rear-next=NULL;
}
void EnQueue(LinkQueue *Q,BiTNode e)//入队操作
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
p-data=e;
p-next=NULL;
Q-rear-next=p;
Q-rear=p;
}
BiTNode DeQueue(LinkQueue *Q)//出对操作
{
BiTNode e;QueuePtr p;
p=Q-front-next;
e=p-data;
Q-front-next=p-next;
if(Q-rear==p)
Q-rear=Q-front;
free(p);
return (e);
}
int QueueEmpty(LinkQueue *Q)//判断队列是否为空
{
if(Q-front==Q-rear )
return 1;
else
return 0;
}
BiTree CreateBiTree()//创建二叉树
{
char p;BiTree T;
scanf("%c",p);
if(p==' ')
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));
T-data=p;
T-lchild=CreateBiTree(T-lchild);
T-rchild=CreateBiTree(T-rchild);
}
return (T);
}
void PreOrder(BiTree T)//先序
{
if(T!=NULL)
{
printf("%c",T-data);
PreOrder(T-lchild);
PreOrder(T-rchild);
}
}
void LevelOrder(BiTree T)//层次遍历
{
LinkQueue Q; BiTNode p;
InitQueue(Q);
EnQueue(Q,*T);
while(!QueueEmpty(Q))
{
p = DeQueue(Q);
printf("%c",p.data);
if(p.lchild!=NULL)
EnQueue(Q,*(p.lchild));
if(p.rchild!=NULL)
EnQueue(Q,*(p.rchild));
}
}
void main()
{
BiTree Ta;
Ta=CreateBiTree();
printf("层次遍历:");
printf("\n");
LevelOrder(Ta);
printf("\n");
printf("先序遍历:");
printf("\n");
PreOrder(Ta);
}
层次使用非递归的，用到队列
先序是用递归的
创建树使用先序递归建树
输入个例子：
abc**de*f**g***(注意*代表空格，因为空格你看不到就不好表示).
递归一直给人的感觉是简洁且优雅，但是在面对较大规模的问题时，递归的弊端就渐渐暴露出来了。因为大量栈的使用导致程序运行速度变得很慢，所以递归算法需要改进。
1.尾递归：函数返回之前的最后一个操作若是递归调用，则该函数进行了尾递归。
但是我发现尾递归貌似并没有很显著的作用？？？（值得深究）
2.递归改递推，举例斐波拉切数列
递归算法大于40之后就会变得很慢，甚至算不出来。而递推算法可以算更大的数而且算得更快（ 即使用了long，但是超过50还是会溢出gg ）。
所以面额拼凑问题就需要使用 递推法 ，一个一个算，看似非常傻但是却比递归好用，或许这就是 大智若愚 吧。
比较难理解的可能是 m[j]+=m[j-den[i]];其等价于之前提到的递推式（1020,100）=（1020-100,100）+（1020,50），但是我们发现（1020,50）没了，这是因为之前已经加上去了。
在这个两层循环中，第一层就是以不同的面额做循环，例如（5,5）=（0,5）+（5,1），之所以省略掉了（5,1）是因为在之前就已经将（5,1）加上去了（ m[j]=1 ）,所以可以直接 m[j]+=m[j-den[i]] .当面额为5循环完毕之后，就可以开始面额为10的循环了。（10,10）=（5,10）+（10，1）=（5,5）+（10,1），由于之前（10,1）已经加上去了，所以直接加上（5,5）就可以了。一次类推直到面额100循环完毕，结果就出来了。（感觉没有讲清楚）
碰到的问题：
1.10000的时候出现溢出。原因：之前在intellij（java）中写的时候用long（64位）没问题，但是 C语言（dev c++和VS）long是32位的 ，所以使用long long
2.dev c++使用的是gcc编译器支持 动态数组 ，VS不支持所以一开始报错。改为 long long *m=new long long[money+1];