p8 函数：计算xn与阶乘与数组排序与大写转为小写的数组

用递归函数计算xn的值（提示：xn =x*xn-1，当n=1时，xn =x）

#include
void main()
{ double x, root;
  int n;
  double fun(int n,double x);
  printf("Input x,n:");
  scanf("%lf%d",&x,&n);
  root=fun(n,x);
  printf("Root=%f\n",root);
}
double fun(int n,double x)
{  if(n==1)
     return x;
   else
     return x*fun(n-1,x);
}

这里是简单的函数循环，这里x*fun(n-1,x) ，这里fun(n-1,x)一直会乘到最后一个相当于就是x*x*x.....*x一共n个这样的式子

输入整数n值，求1!+2!+3!+…+n!，要求阶乘求值用函数的递归调用实现。

#include
int main()
{
	int i,n;
	double sum;
        double f(int i);
	sum=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	   sum=sum+f(i);
	printf("%e\n",sum);
	return 0;
}
double f(int i)
{
	double a;
	if(i==1)
	   a=1;
	else
	   a=f(i-1)*i;
	return a;
}

这里  a=f(i-1)*i;就是上面个那个数字相乘，而这里用循环去赋值给i，用阶乘去给sum加的值

设计一个通用的排序函数(根据用户输入的数据和个数)，要求在主函数中输入要排序的数据，然后调用排序函数执行排序功能，再在主函数中显示排序结果。

#include
int main()
{
	void sort(int b[],int n);
	int i,j[100],n;
	printf("输入排序的数列的个数n:");
	scanf("%d",&n);
	printf("输入排序的数列:");
	for(i=0;ib[i+1])
	    {
	    	t=b[i];
	    	b[i]=b[i+1];
	    	b[i+1]=t;
	    }
}

对于这个函数调用，将 "sort(j, n);" 改为 "sort(j[], n);" 是不正确的。 因为在函数调用中，应该直接传递数组名 "j"，而不是数组名后面加上方括号 "[]"。在函数声明和定义中，可以直接使用参数名 b 作为数组形参，函数内部通过 b[i] 来访问数组元素。 如果将 "sort(j, n);" 改为 "sort(j[], n);"，将导致编译错误。

至于冒泡排序的代码。

假设输入的数列为 [5, 1, 4, 2, 8]，数列的个数为 n = 5。

初始状态： [5, 1, 4, 2, 8]

首先，外层循环 j = 0：

- 内层循环遍历未排序的部分，比较相邻的元素，并交换位置。在此例中，内层循环从 i = 0 到 i < n - 1 - j = 4 - 1 - 0 = 3，即从第一个元素开始到倒数第二个元素结束。

- 第一次内层循环交换位置：b[0] = 5 > b[1] = 1，交换位置后数列变为 [1, 5, 4, 2, 8]。

- 第二次内层循环交换位置：b[1] = 5 > b[2] = 4，交换位置后数列变为 [1, 4, 5, 2, 8]。

- 第三次内层循环交换位置：b[2] = 5 > b[3] = 2，交换位置后数列变为 [1, 4, 2, 5, 8]。

- 内层循环结束，此时数列最后一个元素 8 已经排好序。

第一次外层循环结束后的状态： [1, 4, 2, 5, 8] 接下来，外层循环 j = 1：

- 内层循环从 i = 0 到 i < n - 1 - j = 4 - 1 - 1 = 2，即从第一个元素开始到倒数第三个元素结束。

- 第一次内层循环交换位置：b[0] = 1 < b[1] = 4，不需要交换。

- 第二次内层循环交换位置：b[1] = 4 > b[2] = 2，交换位置后数列变为 [1, 2, 4, 5, 8]。

- 内层循环结束，此时数列最后两个元素 5 和 8 已经排好序。 第二次外层循环结束后的状态： [1, 2, 4, 5, 8] 第三次外层循环 j = 2：

- 内层循环从 i = 0 到 i < n - 1 - j = 4 - 1 - 2 = 1，即从第一个元素开始到倒数第四个元素结束。

- 第一次内层循环交换位置：b[0] = 1 < b[1] = 2，不需要交换。

- 内层循环结束，此时数列最后三个元素 4、5 和 8 已经排好序。 第三次外层循环结束后的状态： [1, 2, 4, 5, 8] 第四次外层循环 j = 3：

- 内层循环从 i = 0 到 i < n - 1 - j = 4 - 1 - 3 = 0，即从第一个元素开始到倒数第五个元素结束。

- 内层循环只需要进行一次，因为此时只有一个元素未排序。

- 内层循环结束，此时整个数列已经完成排序。

最终的排序结果为：

[1, 2, 4, 5, 8]

经过 n-1 次外层循环，整个数列完成了升序排序。

编写一个函数，将字符串中的大写字母转换成对应的小字字母。在主函数中输入一个字符串，并调用上述函数进行处理，结果在主函数中输出。

#include
void main( )
{
  void change(char str[20]); //函数声明
  char s[20];
  printf("please input a string:");
  gets(s);   //输入字符串
  change(s);   //调用函数
  printf("changed string:");
  puts(s);  //输出转换后字符串
}
void change(char str[20])  //定义转换函数
{
   int i=0;
   while(str[i]!='\0')
   {
      if(str[i]>='A'&&str[i]<='Z')  //如果是大写字母
          str[i]=str[i]+32;         //转换为小写字母
      i++;
   }
}

1. `gets` 函数：

- `gets` 函数用于从标准输入读取一行字符串，并将其保存到指定的字符数组中。

- `gets` 函数不会检查输入的字符串长度，因此可能会导致缓冲区溢出的安全问题。因此，不推荐使用 `gets` 函数，而推荐使用更安全的 `fgets` 函数来替代。`fgets` 函数可以指定读取的最大字符数，避免缓冲区溢出。

- `gets` 函数在读取完一行字符串后，会将换行符 '\n' 也存储在字符数组中，并且不会自动添加字符串结束符 '\0'。因此，如果使用 `gets` 函数，通常需要手动将换行符替换为字符串结束符 '\0'。

- 示例：`char str[20]; gets(str);`

2. `puts` 函数： - `puts` 函数用于将指定的字符串输出到标准输出，即屏幕上。 - `puts` 函数会自动在输出的字符串末尾添加换行符 '\n'。 -

`puts` 函数只能用于输出字符串，不能用于其他类型的数据。

- 示例：`char str[] = "Hello, World!"; puts(str);`

1. `int` 返回类型的函数：

- `int` 返回类型的函数可以返回一个整数值。

- 函数体内可以使用 `return` 语句返回一个整数值，这个值将作为函数的返回值。

- 示例： ```c int add(int a, int b) { return a + b; } ```

- 在调用 `add` 函数时，可以将返回值赋给一个整数变量，或直接使用返回值进行其他操作。

2. `void` 返回类型的函数：

- `void` 返回类型的函数不返回任何值。

- 函数体内不能包含 `return` 语句，或者 `return` 语句后面不带表达式。

- 这种类型的函数通常被用来执行一些操作或者完成一些任务，而不需要返回具体的数值。

- 示例： ```c void printMessage() { printf("Hello, World!\n"); } ```

- 在调用 `printMessage` 函数时，不能将其返回值赋给变量或使用返回值进行其他操作。

总结：

- `int` 返回类型的函数可以返回整数值，可以将返回值用于其他操作。

- `void` 返回类型的函数不返回任何值，仅用于执行一些操作或完成一些任务。在函数体内不包含 `return` 语句，或者 `return` 语句后面不带表达式。

这里是直接改变数组里面的str的值