递归算法不需要分配额外的存储空间（数据结构问题：写一个递归算法，实现字符串逆序存储，要求不另设串存储空间~急~~）

本文目录

• 数据结构问题：写一个递归算法，实现字符串逆序存储，要求不另设串存储空间~急~~
• 请问一下，递归函数是否有一定限制例如栈的大小和栈的数量
• 递归方法的定义
• 递归算法怎么理解
• 要面试算法工程师，大神给点相关经验啊
• 递归程序空间复杂度
• 递归算法是什么
• c语言递归问题

数据结构问题：写一个递归算法，实现字符串逆序存储，要求不另设串存储空间~急~~

删除不好做，因为你是一个文件内容的删除。
可以用字符串数组来保存每一行的值，删除了之后，再重新保存进去。
可以这样做：比如说你的文件路径：c:/a.txt
1.File file = new File("c:/a.txt");
2.BufferedReader reader = new BufferedReader(file);
3.byte;
4.String str = reader.read(strValue);//按文件大小一次读入
5.String rows = str.split("\r\n");//按换行符拆分，即数组的每一条，对应文件每一行的内容。
6.如果要删除按条件删除某一行，只需要判断字符串数组是否存在这一行了，如果存在，替换为“”即可。
7.Writer writer = new FileWriter(file);
8.
for(int i=0;i《rows.length;i++){
writer.write(rows);
}
只是分析了一下，具体步骤还是你来完成了。。
RandomAccessFile raf = new RandomAccess("wenjian.txt");
char ch;
char to = ;
boolean get = false;
while(get){
raf.readChars(ch);
if(ch==’s’){
get = true;
}
}
raf.seek(raf.getFilePointer() -6 );
raf.writeChars(to);
这个代码就是把wenjian.txt中出现的第一个dds修改成ssx。

请问一下，递归函数是否有一定限制例如栈的大小和栈的数量

肯定是有限制的。
递归是很消耗堆栈资源的，递归次数太多了肯定会溢出的。确切地说，是函数调用本身就会消耗堆栈资源，不过函数调用结束的时候这个函数使用的堆栈空间会被返还，所以问题不大，很少能看到程序栈满的情况。但是递归是个例外，它是一个函数循环调用自身的过程，在递归结束之前，堆栈使用量会一直增长。程序会不会溢出，就看在栈满之前，你的递归函数能否返回····
windows中的程序栈具体多大还真不太清楚。但是强烈建议不要用递归，因为那个实在是消耗有点大。递归是种编程的理念，但是实际用到的比较少，毕竟谁都知道这个东西次数多了会溢出。
直接把代码改一改，改成迭代不就完事了。

递归方法的定义

1、定义是递归的：

（1）n!的递归实现：

递归方法：

public class Method {    int fun(int n){    if(n==1)        return 1;    else
return(fun(n-1)*n);
}
}
public class RecursionDemo {    public static void main (String args){
Method m=new Method();      int num=m.fun(3);
System.out.println(num);
}
}

递归方法分析：

（1）该方法是直接递归，即自己调用自己。

例如：在执行fun(3)的时候，先执行fun（2）*3，而fun（2）=fun（1）*2，fun（1）=1。

（2）递归过程将问题的规模逐步缩小，参数的大小每次减1。一个个重复的过程，通过调用自身，减少了代码量。

（3）因为递归调用语句是在最后一句，因此，这种递归方式也称为尾递归。

2、数据结构是递归的：

       单链表的存储结构定义。

3、问题的求解是递归的：

#include《stdio.h》 #include《malloc.h》 #include《stdlib.h》#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10#define OVERFLOW -2#define ERROR 0
#define OK 1typedef int ElemType;
typedef struct{ //存储结构 ElemType *elem; //指针类型 int length;
int listsize;
}SqList;//顺序表的结构类型 typedef int Status;
Status InitList(SqList &L){        
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//动态分配存储空间 if(!L.elem) exit(OVERFLOW);  //分配失败退出 L.length=0;                  //空表 L.listsize=LIST_INIT_SIZE; //初始存储容量 return OK;
}
Status ListInsert(SqList &L,int i,ElemType e){//在第 i 个元素前插入一个新的元素e if(i《1 || i 》 L.length+1) return ERROR; //i值不合法 if(L.length》=L.listsize) //存储空间不足 {
ElemType * newbase=(ElemType *)realloc(L.elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW); //分配失败 L.elem=newbase;
L.listsize=LIST_INIT_SIZE+LISTINCREMENT;
}
for (int j=L.length; j》=i; --j)
L.elem;
L.elem=e;
L.length++;return OK;
}
Status ListEmpty(SqList L){ //判断顺序表是否为空return L.length == 0;
}
Status ListPrint(SqList &L) {
printf(" 顺序表为： ");
if (ListEmpty(L)) {
printf(" 空。 \n");
return ERROR;
}
for (int i=0; i《L.length; ++i)
{
printf("%-4d ", L.elem);
}
printf("\n");
return OK;
}int Sum(SqList L,int i){    if(i==L.length)    return 0;    else
return(L.elem+Sum(L,i+1));
}
main(){
SqList L;
ElemType e;
int i,j;
InitList(L);
printf(" 请输入你想创建的顺序表中元素的个数： ");
scanf("%d",&i);
if(i《1) printf(" 您输入的值有误，无法创建顺序表。 \n");
else {
printf(" 请您依次输入您想创建的顺序表的元素： ");
for(j=1;j《=i;j++)
{
scanf("%d",&e);
ListInsert(L,L.length+1,e); //尾插 }
}
ListPrint(L); //遍历顺序表 int result=Sum(L,0);
printf( "顺序表所有元素的和为：%d",result);
}

这个程序是求解顺序表的元素的和，从顺序表的第一个元素开始，依次向后查找元素，并进行求和运算。

递归算法怎么理解

问题一：递归算法还不是很理解!!高手教一教! 递归（recursion）是指把一个大的问题转化为同样形式但小一些的问题加以解决的方法。C语言允许一个函数调用它本身，这就是递归调用。即在调用一个函数的过程中又直接或间接地调用函数本身。不加控制的递归都是无终止的自身调用，程序中是绝对不应该出现这种情况的。为了防止无休止的递归，程序中应控制递归的次数，在某条件成立时进行递归，条件不成立不进行递归调用。并且在递归的调用过程中，不断改变递归的条件，以使递归条件不再成立。
同一问题可能既可以用递归算法解决，也可以用非递归算法解决，递归往往算法设计简单，出奇制胜，而普通算法（通常用循环解决）往往设计稍复杂。但执行效率递归算法逊于循环算法。递归反复调用自己，需要占用较多内存和计算机时间。但有一些问题只有用递归方法才能解决，如著名的汉诺塔问题。
递归程序设计的关键就是考虑问题的两种情况，一种是普遍情况即函数值等于把问题递推一步后的本函数的调用，一种是极端或端点情况，此时函数值有确定的一个值而无须再调用本函数。递归的过程就是从普遍情况逐步过渡到端点情况的过程。
例子：
5个坐在一起论年龄，问第五个人多少岁？他说比第四个人大两岁。问第四个人多少岁，他说比第三个人大两岁。问第三个人多少岁，他说比第二个人大两岁。问第二个人多少岁，他说比第一个人大两岁。问第一个人多少岁，他说10岁。请问第五个人几岁？
int age(int n)
{ int x;
if(n》1) x=age(n-1)+2;
else if(n==1) x=10;
return x;
}
void main( )
{ printf(%d,age(5));}

问题二：什么是递归算法 递归算法就是一个函数通过不断对自己的调用而求得最终结果的一种思维巧妙但是开销很大的算法。
比如：
汉诺塔的递归算法：
void move(char x,char y){
printf(%c--》%c\n,x,y);
}
void hanoi(int n,char one,char two,char three){
/*将n个盘从one座借助two座，移到three座*/
if(n==1) move(one,three);
else{
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}
main(){
int n;
printf(input the number of diskes:);
scanf(%d,&n);
printf(The step to moving %3d diskes:\n,n);
hanoi(n,’A’,’B’,’C’);
}
我说下递归的理解方法
首先：对于递归这一类函数，你不要纠结于他是干什么的，只要知道他的一个模糊功能是什么就行，等于把他想象成一个能实现某项功能的黑盒子，而不去管它的内部操作先，好，我们来看下汉诺塔是怎么样解决的
首先按我上面说的把递归函数想象成某个功能的黑盒子，void hanoi(int n,char one,char two,char three); 这个递归函数的功能是：能将n个由小到大放置的小长方形从one 位置，经过two位置 移动到three位置。那么你的主程序要解决的问题是要将m个的汉诺块由A借助B移动到C，根据我们上面说的汉诺塔的功能，我相信傻子也知道在主函数中写道：hanoi(m,A,B,C)就能实现将m个块由A借助B码放到C，对吧？所以，mian函数里面有hanoi(m,’A’,’C’,’B’);这个调用。
接下来我们看看要实现hannoi的这个功能，hannoi函数应该干些什么？
在hannoi函数里有这么三行
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
同样以黑盒子的思想看待他，要想把n个块由A经过B搬到C去，是不是可以分为上面三步呢？
这三部是：第一步将除了最后最长的那一块以外的n-1块由one位置经由three搬到two 也就是从A由C搬到B 然后把最下面最长那一块用move函数把他从A直接搬到C 完事后 第三步再次将刚刚的n-1块借助hanno处函数的功能从B由A搬回到C 这样的三步实习了n块由A经过B到C这样一个功能，同样你不用纠结于hanoi函数到底如何实现这个功能的，只要知道他有这么一个神奇的功能就行
最后：递归都有收尾的时候对吧，收尾就是当只有一块的时候汉诺塔怎么个玩法呢？很简单吧，直接把那一块有Amove到C我们就完成了，所以hanoni这个函数最后还要加上 if(n==1)move(one,three);（当只有一块时，直接有Amove到C位置就行）这么一个条件就能实现hanoin函数n》=1时......》》

问题三：怎么更好地终极理解递归算法 递归的基本思想是把规模大的问题转化为规模小的相似的子问题来解决。在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了函数调用它自身的情况。另外这个解决问题的函数必须有明显的结束条件，这样就不会产生无限递归的情况了。
需注意的是，规模大转化为规模小是核心思想，但递归并非是只做这步转化，而是把规模大的问题分解为规模小的子问题和可以在子问题解决的基础上剩余的可以自行解决的部分。而后者就是归的精髓所在，是在实际解决问题的过程。

问题四：怎样才能深刻理解递归和回溯？ 递归的精华就在于大问题的分解，要学会宏观的去看问题，如果这个大问题可分解为若干个性质相同的规模更小的问题，那么我们只要不断地去做分解，当这些小问题分解到我们能够轻易解决的时候，大问题也就能迎刃而解了。如果你能独立写完递归创建二叉树，前序、中序、后序递归遍历以及递归计算二叉树的最大深度，递归就基本能掌握了。

回溯本人用得很少，仅限于八皇后问题，所以帮不上啥了。

问题五：二叉树的递归算法到底该怎么理解 这不就是在二叉排序树上的递归查找，看程序
tree& find(c***t T& d, tree& t){
if(t==NULL) return t;如果二叉树为空则返回空，查找失败
if(t-》data==d) return t;否则，如果当前根结点关键码为d，则查找成功，当前根结点为待查找结点
if(d》t-》data) return find(d, t-》right);如果比根的关键码大就递归查找右子树
return find(d, t-》left);如果比根的关键码小就递归查找左子树
}
二叉树的递归定义的含义就是非空二叉树，除了根以外，左右子树都是二叉树（可以为空）

问题六：怎么理解递归算法?我看了代码但还是不理解? 函数自己调用自己就是递归啊。
从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事。讲的内容是：
从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，讲
从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事……
跟循环差不多。而且浪费栈空间，效率不高。能够转化为循环最好。

问题七：数据结构中的二叉树中的递归怎么理解？ 以中序遍历为例，思想是：
若二叉树为空，则空操作；否则
（1）中序遍历左子树
（中序遍历左子树时也是这三步）
（2）访问根结点
（3）中序遍历右子树
（当然右子树也是重复着三步）
示例代码：
int InOrderTraverse(BiTree T)
{
if(T)
{
InOrderTraverse(T-》lchild);
printf(%d\t,T-》data);
InOrderTraverse(T-》rchild);
}
return OK;
}

问题八：java递归算法，怎么理解？？？ n! = (n-1)*n！
简单理解，就是目前的所有任务，等于前面所有的任务+现在的任务。
比如你求 1。。。100的加法总和
实际上是 1... 99 的加法总和 + 100 就是了。
这就是递归的来源。
你只需要计算你前一步的任务，然后加上自己，就OK了。
前一步，在再次调用前前一步......

问题九：新手一个，有什么更好理解递归的方法吗？（c++） 递归的话就是重复调用方法直到满足条件为止就停止这个方法，就跟循环类似，不过循环使用的方法一边比较简单

问题十：递归的原理解释 递归的底层实现其实是一个栈.栈的特点是后进先出,也就是最后进入栈的事件是最先被处理的.
递归就是这样运作.比如计算阶乘函数F(n)=n!=n*F(n-1)=....
写成递归,我用java
public static long F(long num){
if(num

要面试算法工程师，大神给点相关经验啊

算法是比较复杂又基础的学科，每个学编程的人都会学习大量的算法。而根据统计，以下这18个问题是面试中最容易遇到的，本文给出了一些基本答案，供算法方向工程师或对此感兴趣的程序员参考。
1)请简单解释算法是什么?
算法是一个定义良好的计算过程，它将一些值作为输入并产生相应的输出值。简单来说，它是将输入转换为输出的一系列计算步骤。
2)解释什么是快速排序算法?
快速排序算法能够快速排序列表或查询。它基于分割交换排序的原则，这种类型的算法占用空间较小，它将待排序列表分为三个主要部分：
·小于Pivot的元素
·枢轴元素Pivot(选定的比较值)
·大于Pivot的元素
3)解释算法的时间复杂度?
算法的时间复杂度表示程序运行完成所需的总时间，它通常用大O表示法来表示。
4)请问用于时间复杂度的符号类型是什么?
用于时间复杂度的符号类型包括：
·Big Oh：它表示小于或等于目标多项式
·Big Omega：它表示大于或等于目标多项式
·Big Theta：它表示与目标多项式相等
·Little Oh：它表示小于目标多项式
·Little Omega：它表示大于目标多项式
5)解释二分法检索如何工作?
在二分法检索中，我们先确定数组的中间位置，然后将要查找的值与数组中间位置的值进行比较，若小于数组中间值，则要查找的值应位于该中间值之前，依此类推，不断缩小查找范围，直至得到最终结果。
6)解释是否可以使用二分法检索链表?
由于随机访问在链表中是不可接受的，所以不可能到达O(1)时间的中间元素。因此，对于链表来说，二分法检索是不可以的(对顺序链表或排序后的链表是可以用的)。
7)解释什么是堆排序?
堆排序可以看成是选择排序的改进，它可以定义为基于比较的排序算法。它将其输入划分为未排序和排序的区域，通过不断消除最小元素并将其移动到排序区域来收缩未排序区域。
8)说明什么是Skip list?
Skip list数据结构化的方法，它允许算法在符号表或字典中搜索、删除和插入元素。在Skip list中，每个元素由一个节点表示。搜索函数返回与key相关的值的内容。插入操作将指定的键与新值相关联，删除操作可删除指定的键。
9)解释插入排序算法的空间复杂度是多少?
插入排序是一种就地排序算法，这意味着它不需要额外的或仅需要少量的存储空间。对于插入排序，它只需要将单个列表元素存储在初始数据的外侧，从而使空间复杂度为O(1)。
10)解释什么是“哈希算法”，它们用于什么?
“哈希算法”是一个哈希函数，它使用任意长度的字符串，并将其减少为唯一的固定长度字符串。它用于密码有效性、消息和数据完整性以及许多其他加密系统。
11)解释如何查找链表是否有循环?
要知道链表是否有循环，我们将采用两个指针的方法。如果保留两个指针，并且在处理两个节点之后增加一个指针，并且在处理每个节点之后，遇到指针指向同一个节点的情况，这只有在链表有循环时才会发生。
12)解释加密算法的工作原理?
加密是将明文转换为称为“密文”的密码格式的过程。要转换文本，算法使用一系列被称为“键”的位来进行计算。密钥越大，创建密文的潜在模式数越多。大多数加密算法使用长度约为64到128位的固定输入块，而有些则使用流方法。
13)列出一些常用的加密算法?
一些常用的加密算法是：
·3-way
·Blowfish
·CAST
·CMEA
·GOST
·DES 和Triple DES
·IDEA
·LOKI等等
14)解释一个算法的最佳情况和最坏情况之间有什么区别?
·最佳情况：算法的最佳情况解释为算法执行最佳的数据排列。例如，我们进行二分法检索，如果目标值位于正在搜索的数据中心，则这就是最佳情况，最佳情况时间复杂度为0。
·最差情况：给定算法的最差输入参考。例如快速排序，如果选择关键值的子列表的最大或最小元素，则会导致最差情况出现，这将导致时间复杂度快速退化到O(n2)。
15)解释什么是基数排序算法?
基数排序又称“桶子法”，是通过比较数字将其分配到不同的“桶里”来排序元素的。它是线性排序算法之一。
16)解释什么是递归算法?
递归算法是一个解决复杂问题的方法，将问题分解成较小的子问题，直到分解的足够小，可以轻松解决问题为止。通常，它涉及一个调用自身的函数。
17)提到递归算法的三个定律是什么?
所有递归算法必须遵循三个规律：
·递归算法必须有一个基点
·递归算法必须有一个趋向基点的状态变化过程
·递归算法必须自我调用
18)解释什么是冒泡排序算法?
冒泡排序算法也称为下沉排序。在这种类型的排序中，要排序的列表的相邻元素之间互相比较。如果它们按顺序排列错误，将交换值并以正确的顺序排列，直到最终结果“浮”出水面。
满意记得采纳哈

递归程序空间复杂度

空间复杂度:
是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,简单说就是递归集算时通常是反复调用同一个方法，递归n次，就需要n个空间。
时间复杂度：
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f (n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
按数量级递增排列，常见的时间复杂度有：
常数阶O(1),对数阶O(log2n),线性阶O(n),
线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...，
k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

递归算法是什么

递归算法（英语：recursion algorithm）在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。

递归式方法可以被用于解决很多的计算机科学问题，因此它是计算机科学中十分重要的一个概念。绝大多数编程语言支持函数的自调用，在这些语言中函数可以通过调用自身来进行递归。

计算理论可以证明递归的作用可以完全取代循环，因此在很多函数编程语言（如Scheme）中习惯用递归来实现循环。

递归程序

在支持自调用的编程语言中，递归可以通过简单的函数调用来完成，如计算阶乘的程序在数学上可以定义为：

这一程序在Scheme语言中可以写作：

(define (factorial n)  (if (= n 0)      1      (* n (factorial (- n 1)))))

不动点组合子

即使一个编程语言不支持自调用，如果在这语言中函数是第一类对象（即可以在运行期创建并作为变量处理），递归可以通过不动点组合子（英语：Fixed-point combinator）来产生。以下Scheme程序没有用到自调用，但是利用了一个叫做Z 算子（英语：Z combinator）的不动点组合子，因此同样能达到递归的目的。

(define Z  (lambda (f)    ((lambda (recur) (f (lambda arg (apply (recur recur) arg))))     (lambda (recur) (f (lambda arg (apply (recur recur) arg)))))))(define fact  (Z (lambda (f)       (lambda (n)         (if (《= n 0)             1             (* n (f (- n 1))))))))

这一程序思路是，既然在这里函数不能调用其自身，我们可以用 Z 组合子应用(application)这个函数后得到的函数再应用需计算的参数。

尾部递归

尾部递归是指递归函数在调用自身后直接传回其值，而不对其再加运算。尾部递归与循环是等价的，而且在一些语言（如Scheme中）可以被优化为循环指令。 因此，在这些语言中尾部递归不会占用调用堆栈空间。以下Scheme程序同样计算一个数字的阶乘，但是使用尾部递归： 

(define (factorial n)  (define (iter product counter)    (if (》 counter n)        product        (iter (* counter product)              (+ counter 1))))  (iter 1 1))

能够解决的问题

• 数据的定义是按递归定义的。如Fibonacci函数。

• 问题解法按递归算法实现。如Hanoi问题。

• 数据的结构形式是按递归定义的。如二叉树、广义表等。

参考资料

百科-递归算法.百度百科

c语言递归问题

首先我们回答一下，你的这个题目中是有用到递归的。
我们先来了解下什么是递归：
递归的定义：直接或间接调用自己的函数成为递归函数（recursionfunction）。在求解某些具有随意性的复杂问题时经常使用递归，例如求解阶乘或者两个数的最大公约数等。因为这时解的具体“大小”不受限制，函数可以一直递归调用，直到问题解决。
递归的要求：递归函数必须定义一个终止条件；否则，函数就会“永远”递归下去，这意味着函数会一直调用自身直到程序栈耗尽，这种“永远”递归下去的现象叫做“无限递归错误”（infiniterecursion error）。
递归的特点：
1、在函数f()中，会对函数f()自己进行调用。
2、无限递归实际上是不允许的；递归函数必须定义一个终止条件，即什么情况下终止递归，终止继续调用自己，如果没有终止条件，那么函数将一直调用自己，知道程序栈耗尽，这时候等于是写了一个Bug！
3、 递归算法解题通常代码比较简洁，但不是很容易读懂。
4、 递归的调用需要建立大量的函数的副本，尤其是函数的参数，每一层递归调用时参数都是单独的占据内存空间，他们的地址是不同的，因此递归会消耗大量的时间和内存。而非递归函数虽然效率高，但相对比较难编程。
5、 递归函数分为调用和回退阶段，递归的回退顺序是它调用顺序的逆序。
如果以上对你有帮助，青采纳一下， 谢谢。