函数调用，递归和栈的大小

已于 2022-10-31 21:53:04 修改
阅读量457 收藏 1
点赞数
文章标签： c语言
于 2022-10-29 11:50:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54005982/article/details/127585151
版权

#define _CRT_SECURE_NO_WARNINGS//必须放在第一行
#include <stdio.h>
#include <math.h>
/*
* 递归:直接或者间接调用自己
* 函数调用需要用到栈
* 栈的大小:1M
* 局部变量:定义在函数内部的变量,包括形参.局部变量分配在栈中
*/
int Age1(int n)
{
    int tmp = 10;
    for (int i = 1; i < n; i++)
    {
        tmp += 2;
    }
    return tmp;
}

//Age(5):第5个人的年龄
//Age(4):第4个人的年龄
//Age(3):第3个人的年龄
//Age(2):第2个人的年龄
//Age(1):第1个人的年龄
//Age(n):第n个人的年龄
//Age(n-1):第n-1个人的年龄
int Age(int n)//求年龄
{
    int tmp; //年龄
    if (n == 1)
        tmp = 10;
    else
        tmp = Age(n-1) + 2;
    return tmp;

    //return n == 1 ? 10 : Age(n - 1) + 2;//等同上面的代码
}

//用递归求阶乘
long long Fac(int n)
{
    if (n == 0 || n == 1)
        return 1;
    return n * Fac(n - 1);
}

//利用递归求1+2+3+...+n
int Sum(int n)
{
    if (n == 0 || n == 1)
        return n;
    return Sum(n - 1) + n;
}

long long Fibon1(int n)
{
    long long f1 = 1;
    long long f2 = 1;
    long long f3 = 1;
    for (int i = 2; i < n; i++)
    {
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

//递归实现斐波那契数列
//斐波那契数列是最不适合使用递归的例子(太慢)
long long Fibon(int n)
{
    if (n == 1 || n == 2)
        return 1;
    return Fibon(n - 1) + Fibon(n - 2);
}

int main()
{
    printf("%lld\n", Fibon(50));
    //for (int i = 1; i <= 10; i++)
    //    printf("%lld,",Fibon1(i));

    /*printf("%d\n",Sum(10));
    printf("%d\n", Sum(100));
    printf("%d\n", Sum(1000));*/
    /*for (int i = 0; i < 10; i++)
        printf("%d!=%lld\n",i,Fac(i));*/
    /*for (int i = 1; i <= 5; i++)
        printf("%d\n",Age(i));*/

    //printf("%d\n", Age1(5000));//可以
    //printf("%d\n",Age(5000));//崩溃,栈溢出,递归次数太多,超过栈容量

    return 0;
}

//测试栈的大小
//int main()
//{
//    //char arr[1024];//1k ,可以
//    //char arr[1024 * 1024];//1M,程序崩溃
//    char arr[1024 * 1000];// 接近1M,可以
//    printf("好了\n");
//
//    return 0;
//}
//1.利用函数, 实现判断一个数字是否为素数, 并测试7, 9, 10, 91
//bool IsPrimer(int n)
//{
//    for (int i = 2; i <= sqrt(n); i++)
//    {
//        if (n % i == 0)
//            return false;
//    }
//    return true;
//}
//int main()
//{
//    for (int i = 2; i < 100; i++)//测试用例
//    {
//        if (IsPrimer(i))
//            printf("%d\n",i);
//    }
//    return 0;
//}

//2.利用函数实现求斐波那契数列数列的第n项,并测试前10项
//long long Fibon(int n)
//{
//    long long f1 = 1;
//    long long f2 = 1;
//    long long f3 = 1;
//    for (int i = 2; i < n; i++)
//    {
//        f3 = f1 + f2;
//        f1 = f2;
//        f2 = f3;
//    }
//    return f3;
//}
//
//int main()
//{
//    for (int i = 1; i <= 20; i++)//测试
//    {
//        printf("%lld,",Fibon(i));
//    }
//    return 0;
//}

//3.利用函数实现折半查找,如果找到数据返回该数据的下标,失败返回-1.函数设计如下:
//int BinSearch(int arr[], int len, int key)//arr为数组名,len为数组长度,key为需要查找的数据
//{
//    int low = 0;
//    int high = len - 1;
//    int mid;
//    while (low <= high)
//    {
//        mid = (low + high) / 2;
//        if (arr[mid] == key)
//            return mid;
//        else if (arr[mid] < key)//在后面找
//            low = mid + 1;
//        else
//            high = mid - 1;
//    }
//    return -1;
//}
//
//int main()
//{
//    int arr[] = {1,3,5,6,7,8,9,12,34,56,78,99,100};
//    int index;
//    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        index = BinSearch(arr, sizeof(arr) / sizeof(arr[0]), arr[i]);
//        if (index >= 0)
//            printf("%d找到了,在%d下标\n", arr[i], index);
//        else
//            printf("%d没有找到\n",arr[i]);
//    }
//    int n = 0;
//    index = BinSearch(arr, sizeof(arr) / sizeof(arr[0]), n);
//    if (index >= 0)
//        printf("%d找到了,在%d下标\n", n, index);
//    else
//        printf("%d没有找到\n", n);
//    n = 10;
//    index = BinSearch(arr, sizeof(arr) / sizeof(arr[0]), n);
//    if (index >= 0)
//        printf("%d找到了,在%d下标\n", n, index);
//    else
//        printf("%d没有找到\n", n);
//
//    n = 110;
//    index = BinSearch(arr, sizeof(arr) / sizeof(arr[0]), n);
//    if (index >= 0)
//        printf("%d找到了,在%d下标\n", n, index);
//    else
//        printf("%d没有找到\n", n);
//
//    return 0;
//}

//4.利用函数实现字符串拷贝(不能使用库函数).
//void Mystrcpy(char des[], char src[])//des=src
//{
//    int i;
//    for (i = 0; src[i] != '\0'; i++)
//    {
//        des[i] = src[i];
//    }
//    des[i] = '\0';
//}
//
//int main()
//{
//    char str1[100];
//    char str2[] = "hello world";
//    Mystrcpy(str1,str2);
//    printf("%s\n",str1);
//
//    return 0;
//}

//5.利用函数实现字符串比较(不能使用库函数).
//int Mystrcmp(const char str1[], const char str2[])
//{
//    int i;
//    for (i = 0; str1[i] != '\0' && str2[i] != '\0'; i++)
//    {
//        if (str1[i] > str2[i])
//            return 1;
//        else if (str1[i] < str2[i])
//            return -1;
//    }
//    return str1[i] - str2[i];
//}
//
//int main()
//{
//    printf("%d\n",Mystrcmp("abc","xy"));
//    printf("%d\n", Mystrcmp("abc", "abc"));
//    printf("%d\n", Mystrcmp("abc", "ab"));
//
//    return 0;
//}

#define _CRT_SECURE_NO_WARNINGS//必须放在第一行
#include <stdio.h>
#include <math.h>
#include <time.h>

/*
* Debug:程序员使用的版本.包含调试信息,程序没有优化,生成可执行程序比较大
* Release:普通用户使用的版本,没有调试信息,程序有优化(编译器自行优化),生成的可执行程序比较小
*算法效率分析:
*   时间复杂度:
*   空间复杂度:
* 
*/
int main()
{
    return 0;
}


#if 0
//1.利用递归实现猴子吃桃。 猴子第一天摘若干桃子,
//当即吃了一半,不过瘾又吃了一个。 第 2 天早上又将剩下的
//桃子吃掉一半,又多吃了一个。 以后每天早上都吃前一天剩下
//的一半零一个。 到第 10 天早上想吃时,就只剩一个桃子了。
//求第一天摘的桃子数
int Peach(int n)
{
    if (n == 10)
        return 1;
    return (Peach(n + 1) + 1) * 2;
}

/*
* 2.利用递归将一个整数 n 顺序输出每一位,中间用空格隔开。
例如输入 483,输出 4 8 3,n 的位数不确定。
*/
//Show(483):4 8 3
//Show(48):4 8
void Show(int n)//顺序输出n的每一位
{
    if (n >= 10)
        Show(n/10);
    printf("%d ",n%10);
}

long long Fibon1(int n)
{
    long long f1 = 1;
    long long f2 = 1;
    long long f3 = 1;
    for (int i = 2; i < n; i++)
    {
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

//斐波那契数列是最不适合使用递归的例子(太慢)
long long Fibon(int n)
{
    if (n == 1 || n == 2)
        return 1;
    return Fibon(n - 1) + Fibon(n - 2);
}

int g_count = 0;//统计汉诺塔一共移动的次数
//将盘子从x移到y
void Move(char x, char y)
{
    printf("%c->%c\n",x,y);
    g_count++;
}

//汉诺塔,将n个盘子,从a,通过b,移到c
void Hanio(int n, char a, char b, char c)
{
    if (n == 1) //只有最后一个盘子,直接从a移到c
        Move(a,c);//printf("%c->%c\n",a,c);
    else
    {
        Hanio(n-1,a,c,b);//将上面的n-1个盘子,从a通过c移到b上面
        Move(a,c);//把最下面的盘子,直接从a移到c//printf("%c->%c\n",a,c);
        Hanio(n - 1, b, a, c);//将n-1个盘子,从b通过a移到c上面
    }
}

int main()
{
    Hanio(5,'A','B','C');
    printf("%d\n",g_count);

    return 0;
}
#endif

//int main()
//{
//    //printf("%d\n",Peach(1));
//    //Show(483);
//    clock_t c1 = clock();
//    Fibon1(44);
//    clock_t c2 = clock();
//    printf("循环执行的时间:%d\n",c2-c1);
//    
//    Fibon(44);
//    clock_t c3 = clock();
//    printf("递归执行的时间:%d\n", c3-c2);
//    
//    return 0;
//}

liuyani12138
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言函数的递归和调用实例分析
09-05
4. **效率问题**：虽然递归代码简洁，但因为额外的函数调用开销和存储需求，递归通常比迭代（非递归）方法效率低。 **五、程序流程** 在上述`fac`函数中，每次调用`fac(n)`时，都会为`t`变量分配新的内存，并检查`...
调用递归大致计算出内存中栈的大小
Eunice_fan1207的博客
01-30 1275
我们通过测试大约计算出栈的大小大约为816k，即不到1MB.
C++栈函数调用
wenixang的博客
08-19 1288
一、 C++库的函数 1.1 头文件 #include<stack> 1.2 栈常用的操作函数 主要包括： 栈的大小 .size() 判断栈是否为空 .empty() 栈顶插入（入栈） .push() 栈顶删除（出栈） .pop() 查看栈顶元素 .top() stack<char> stk; stk.push('a'); //入栈 cout << stk.top() << endl; //查看栈顶元素 stk.pus
vs2010设置堆栈大小的方法和栈区，堆区以及全局区等含义
weixin_58368590的博客
11-16 2809
1、栈区(stack segment)：由编译器自动分配释放，存放函数的参数的值，局部变量的值等。在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M(也有的是1M，总之是一个编译时就确定的常数)，如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。 2、堆区(heap segment) ： 一般由程序员分配释放，若程序员不释放，程序结束时可能由系统回收 。它..
C6262警告和Visual Studio的栈大小设置
Humbunklung的专栏
07-20 4487
静态数组空间往往和栈有关，近期看算法书，为了提升效率，常常直接一个静态数组来实现里面的算法——栈（stack）由系统或编译器分配，性能要优于人工分配的堆（heap）。那么，好东西必然要少，所以默认栈的大小是有限制的。网上的说法多是Linux默认8MB，Windows2MB或1MB，事实上我们使用静态数组的时候会小于这个值，因为栈里还有其它内容。...
程序中关于堆栈大小的划定
热门推荐
liuhuiyi的专栏
11-21 2万+
昨天在做小猪登山的题目碰到了数组容量太大的问题，今天做一个总结。      首先，参考了Slyar的文章《C语言 全局变量和局部变量的大小限制》直接贴上。 #include int main(){ int a[1000000];//局部变量 return 0; } 编译运行后发现溢出错误。 #include int a[1000000];//全局变量 int main(){
VC++ 6.0 中修改默认栈空间大小的方法
BryantGuo的专栏
04-18 4910
之前用VC++ 6.0编写程序进行较大规模的数组处理时，经常会遇到栈空间溢出（stack overflow）的问题，有时会弹出WINDOWS的警告，某内存不能read。如果新手想不到错误的原因是因为栈溢出的话，调试起来会非常头痛。     我最近在对文本文件中的100多万行的浮点数进行按大小排序，首先想到的必然是用快速排序算法，快排利用到了递归的方法，递归方法会用到栈这个数据结构。VC++6.0
408函数-递归调用-全局变量和局部变量
最新发布
07-07
1. **参数对应关系**：在函数调用时，实参与形参之间需要一一对应，包括数量、类型和顺序。 2. **形参的作用域**：形参本质上是局部变量，其作用域仅限于函数内部。如果函数没有被调用，则形参不会占用内存空间。 3....
JavaScript中匿名函数的递归调用
10-20
在JavaScript中，递归是一种强大的编程技术，它指的是函数在其定义内部调用自身的过程。递归通常用于解决那些可以通过简化自身来求解的问题，如树的遍历、阶乘计算等。在本篇讨论中，我们将关注如何在匿名函数中实现...
C++使用递归函数和栈操作逆序一个栈的算法示例
12-31
本文实例讲述了C++使用递归函数和栈操作逆序一个栈的...2、递归函数二：逆序栈，调用递归函数一实现。 C++实现： class Solution { public: //递归函数一 static int getAndRemoveStackLastElem(stack<int>& s) {
Visual Studio 2015设置栈大小
qq_42209977的博客
11-12 2311
最近在VS 上面调试代码，发现realloc（）函数返回错误，堆栈内存不够。 1、realloc函数 realloc函数说明 realloc经常参加面试。 图解说明 如果在堆区需要从10空间大小扩展到20个空间大小，步骤如下： 现在要扩展至20个空间： 如果从array指针向后，够20个空间则直接申请。 在申请完之后，realloc函数返回新申请的堆内存空间首地址。也就是继续使用开始定义的指针变量 array 接收堆内存新的20个空间。 扩展前后的指针变量array所指向内存地址是同一个地址。 如果原
一种简单通用的获取函数栈空间大小的方法
星沉地动
07-27 2173
有些时候我们需要评估某个函数所使用的栈空间大小，比如创建线程的时候，我们需要估算该线程函数所需的栈空间，分配合适的线程栈。 本文介绍一种简单的方法，来获取某个函数所占用的栈空间大小。...
程序栈到底多大
后台开发
10-01 1万+
有次面试被问到程序栈多大，故这里记一下。 栈大小与编译器有关，通常栈大小为1M。但在平时应用程序中，由于函数会使用栈结果，所以只能用略小于1M大小的栈 对于全局变量来说，与编译器有关。默认情况下全局变量数组大小是2G。由于程序本身的应用，所以只能使用小于2G大小 对于Heap来说，与程序是32位还是64位，以及编译器都有关 32位程序可以申请的堆大小最大是2G。实际上只能小于2G，64位下也只能最多获得4G内存，实际上小于4G ...
关于递归调用栈需要空间大小分析
ai309581115的专栏
10-01 2325
面试的时候被问到了递归调用的问题 int fun(int n) {}
递归占用的栈帧大小（待验证）
dezhendiao5625的博客
03-26 205
int fact(int n) { //求n的阶乘 if(n < 0) return 0 else if (n == 0) return 1; else if (n == 1) return 1; else return n*fact(n-1); } 一般而言,在X8632位系统中,一次函数调...
C语言 -函数、栈区与栈桢
AKUANer的博客
10-23 455
question1： 函数内 存在 栈区 默认栈的大小是1M 系统的做法：应用程序总共有1M的空间 想象成一座高楼 一层一层垒起来 每一层叫做栈帧；一个函数住一楼 一个栈帧 int fun(int a){ a+=10; return a; } AddInt(int a,int b) { int c =a +b ; return c; //不能有两个return值 } 若局部...
递归调用的深度与栈的大小
xifengcode
10-24 4840
函数在递归调用时会占用栈的空间，因此，当递归达到一定的深度时，就会出现栈溢出的情况。 下面的代码，函数的参数值为多少，就进行了多少次递归。这个程序直接运行，得不得最终的结果：2000000， 因为栈没有那么大。 #include "stdio.h" int fun(int n) { if(n==1) return 1; return fun(n-1)+1; } int main() { int...
c++扩大递归栈大小
zsr201276的博客
05-21 199
为了调大栈空间，我们就要用一些玄学代码解决，网上的版本都是这样： ```cpp int size = 256
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值