C语言学习笔记22/08/17_c语言中fac(n)

//有一些功能：可以使用迭代的方式实现，也可以使用递归
 
int Fac(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * Fac(n - 1);
}
 
int main()
{
	int n = 0;
	scanf("%d", &n);
 
	int ret = Fac(n);
 
	printf("%d\n", ret);
	return 0;
}

迭代

        对计算机特定程序中需要反复执行的子程序*(一组指令)，进行一次重复，即重复执行程序中的循环，直到满足某条件为止，亦称为迭代。

int count = 0;
//递归可以求解，但是效率太低
int Fib(int n)
{
	//统计第3个斐波那契数的计算机次数
	if (n == 3)
		count++;
 
	if(n <= 2)
		return 1;
	else
		return Fib(n - 1) + Fib(n - 2);
}
 
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
 
	printf("%d\n", ret);
	printf("count = %d\n", count);
 
	return 0;
}

        理论上假设int可以存无限大的数，求到100的阶乘也没有问题。而实际上要运行这段程序，必须要考虑溢出，因为溢出是客观存在的。代码显示为0本质还是因为溢出，一开始溢出的位数不多所以低位会显示一个数，溢出的多了，低位全是0了，所以会显示0。

用迭代的代码效率高

int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 0;
	while (n > 2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}
 
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
 
	printf("%d\n", ret);
 
	return 0;
}

这个代码即使输入10000都能显示一个数字，但数字是错误的，因为要考虑溢出的问题。

斐波那契数列

        指的是这样一个数列：1，1，2，3，5，8，13，21，34，55，89...自然中的斐波那契数列，这个数列从第3项开始，每一项都等于前两项之和。

还有两个拓展问题上网搜的：

汉诺塔问题：

        源于印度一个古老传说。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。问应该如何操作？

解题思路：
首先，我们把三根金刚石柱子编号为A、B、C，其中编号为A的柱子摞着64片黄金圆盘，B、C为空柱，其中，C柱子作为最终摆放圆盘的柱

        首先，我们可以把64个黄金圆盘看作由两个部分组成 ：第64个黄金圆盘和其上的63个黄金圆盘 ，这样我们只要把63个黄金圆盘组成的部分移到编号为B的柱子，然后就可以将第64个黄金圆盘移到C柱上。
        同样，我们也可以把编号为B柱上的63个黄金组成的部分再次分为两个部分，第63个黄金圆盘和其上的62个黄金圆盘，这时，借助编号为A的柱子，将62个黄金圆盘移到A柱上。然后，在把第63个黄金盘移到C柱上，依此类推，这样我们就可以将剩下的黄金圆盘都移到C柱上。
————————————————
版权声明：本文为CSDN博主「Rookie on the road」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45045399/article/details/100580330

青蛙跳台阶：
        一只青蛙可以一次跳 1 级台阶或一次跳 2 级台阶。问要跳上第 n 级台阶有多少种跳法?

解题思路
我们设台阶数位N;
当N=1时，当然只有1种跳法；
当N=2时，青蛙可以跳2次1层和跳1次2层；
当N=3时，当有3层台阶时，青蛙可以选择先跳1层，剩下2层台阶，所以此时就是有2层台阶时的跳法，有2种；当青蛙选择第一次跳2层台阶时，剩下1层台阶，此时有1层台阶时的跳法，所以3层台阶时的方法是：2层台阶的方法 + 1层台阶的方法。
当N=4时，具体跳法为: 1、先跳1层 若先跳1层，则剩下3层，接下来就是3层台阶的跳法。 2、先跳2层 若先跳2层，则剩下2层，接下俩就是2层台阶的跳法，所以4层台阶的方法为：3层台阶的方法+2层台阶的方法。

以此类推，当N=n时，n层台阶的方法为: n-1层台阶的方法+ n-2 层台阶的方法。

int frog(int n)
{
   if(n == 1)
   {
      return 1;
   }
   if(n == 2)
   {
      return 2;
   }
   return frog(n-1) + frog(n-2);
}
int main()
{
   int n;
   scanf("%d",&n);
   int ways = frog(n);
   printf("%d\n",ways);
   return 0;
}

————————————————
版权声明：本文为CSDN博主「RanieMiss」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_52606524/article/details/113037147

一维数组

        数组是一组相同类型元素的集合。

type_t  arr_name[const_n];
 
//type_t:数组元素类型
//arr_name:数组名
//const_n:常量表达式，用来指定数组的大小

数组的初始化

        在创建数组的同时给数组的内容一些合理初始值(初始化)。

int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

strlen() 和sizeof的区别

        strlen() 是一个库函数，计算的是字符串的长度，并且只能作用于字符串，关注点在于字符串中是否有\0 ,计算的是字符串\0 之前的字符个数；
        sizeof 是一个操作符，sizeof 是用来计算变量所占空间大小的，任何类型都可以使用，只关注空间大小，不在乎内存中是否有\0, 而且单位是字节；

一维数组的使用：

int main()
{
	int arr[10] = { 0 };
 
	arr[4] = 5;//[] - 下标引用操作符
	printf("%d\n", arr[4]);
 
	return 0;
}

5

int main()
{
	int arr[10] = { 0 };//数组的不完全初始化
	   //计算数组的元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	//对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
	int i = 0;//做下标
	for (i = 0; i < 10; i++)//这里写10，好不好？
	{
		arr[i] = i;
	}
	//输出数组的内容
	for (i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 1 2 3 4 5 6 7 8 9

int main()
{
	//printf("%x\n", 0x12);
	//printf("%p\n", 0x12);
 
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 
	int* p = arr;//数组名是数组首元素的地址
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d " , *p);
		p++;
	}
	return 0;
}

1 2 3 4 5 6 7 8 9 10

• 数组是使用下标来访问的，下标是从0开始的；
• 数组的大小可通过计算得到；
• 一维数组在内存中是连续存放的；
• 数组随着下标的增长，地址由低到高变化

一堆数组在内存中的存储

int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
 
	for (i = 0; i < sz; ++i)
	{
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}

&arr[0] = 006CFE60
&arr[1] = 006CFE64
&arr[2] = 006CFE68
&arr[3] = 006CFE6C
&arr[4] = 006CFE70
&arr[5] = 006CFE74
&arr[6] = 006CFE78
&arr[7] = 006CFE7C
&arr[8] = 006CFE80
&arr[9] = 006CFE84

 二维数组的创建和初始化

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

二维数组的使用

        二维数组的使用也是通过下标的方式。

int main()
{
	int arr[3][4] = { 0 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			arr[i][j] = i * 4 + j;
			
		}
	}
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	return 0;
}

0 1 2 3 4 5 6 7 8 9 10 11

二维数组完全转换

int main()
{	
	//初始化 - 创建的同时给赋值
	int arr[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
 
	return 0;

监视窗口显示

二维数组不完全转换

int main()
{	
	//初始化 - 创建的同时给赋值
	int arr[3] [4] = { 1,2,3,4,5,6,7 };
 
	return 0;
}

监视窗口显示

二维数组里面用{}转换

int main()
{	
	//初始化 - 创建的同时给赋值
	int arr[3][4] = { {1,2},{3,4},{4,5} };
 
	return 0;
}

二维数组在内存中的存储

int main()
{
 int arr[3][4];
 int i = 0;
 for(i=0; i<3; i++)
 {
 int j = 0;
 for(j=0; j<4; j++)
 {
 printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
 }
 }
 return 0; }

&arr[0][0] = 012FF798
&arr[0][1] = 012FF79C
&arr[0][2] = 012FF7A0
&arr[0][3] = 012FF7A4
&arr[1][0] = 012FF7A8
&arr[1][1] = 012FF7AC
&arr[1][2] = 012FF7B0
&arr[1][3] = 012FF7B4
&arr[2][0] = 012FF7B8
&arr[2][1] = 012FF7BC
&arr[2][2] = 012FF7C0
&arr[2][3] = 012FF7C4

数组越界

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
   int i = 0;
   for(i=0; i<=10; i++)
  {
       printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
  }
return 0;
}

1
2
3
4
5
6
7
8
9
10
-858993460

int main()
{
	int arr[10] = { 1,2,3,4,5 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d\n", *arr);
	//输出结果
	return 0;
}

008FFC40
008FFC40
1