递归函数以及结构体

1：递归函数

斐波那契数列：指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*） 求第五个数。

int fun(int n)
{
    if(n<=2)
    return 1;
    if(n>2)
    return fun(n-1)+fun(n-2);
}
int main(int argc, char const *argv[])
{
    int n;
    scanf("%d",&n);
    int a[n];
   for(int i=1;i<=n;i++)
   {
     a[i]=fun(i);
     printf("%d ",a[i]);
   }
    return 0;
}

求5的阶乘5！ //1*2*3*4*5

递归公式：

1 n<=1

fac(n)=

n*fac(n-1) n>1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int fac(int n)     //n=5    //n=4    //n=3  //n=2 //n=1
{
    if (n <= 1)
        return 1;   //结束递归
    if (n > 1)
        return n * fac(n - 1);   //5*fac(4)  //5*4*fac(3) //5*4*3*fac(2)  //5*4*3*2*fac(1)  //5*4*3*2*1
}

int main()
{
    int n = 5, r = 0;
    r = fac(n);
    printf("%d\n", r);  //120
    return 0;

2：结构体的基本用法

2.1：定义格式

struct 结构体名

{

数据类型 成员变量名1;

数据类型 成员变量名2;

数据类型 成员变量名3;

};

2.1：结构体的赋值方式

<1>定义时直接用花括号赋值：

struct student s1 = {"xiaoming", 1, 18};

<2>点等法赋值

struct student s2 = {

.name ="xiaofang",

.id = 2,

.age =18

};

<3>定义结构体变量时未初始化，需要单独给每个成员赋值。用成员访问符.  

struct student s3;

s3.id=3;

s3.age=19;

strcpy(s3.name, "xiaowang");

3:重新定义:typedef

#include <stdio.h>

//1.给普通数据类型重命名
typedef int size4;

//2. 给指针类重命名
typedef int *int_p;

//3. 给数组类型重名
typedef int intA10[10];

int main()
{
    size4 a = 10;           //相当于 int a;
    int_p p = &a;           //相当于 int *p;
    intA10 arr = {1, 2, 3}; //相当于 int arr[10];

    printf("%d %d\n", a, *p);
    printf("%d\n", arr[1]);

3.1: 先定义结构体，然后重定义

struct flower
{
    char name[32];
    char color[32];
};

typedef struct flower FLOWER;
FLOWER f1;  //等同于 struct flower f1;
}

3.2:结构体数组

定义结构体的同时定义结构体数组

struct student
{
    int id;
    int age;
} s[5];

3.2.2：定义完结构体之后再定义结构体数组

struct student
{
     int id;
     int age;   
};
struct student s[5];

结构体数组输入输出（for循环）

struct student
{
    char name[32];
    int id;
    int bj;
} a[3];
int main(int argc, char const *argv[])
{
    for (int i = 0; i < 3; i++)
        scanf("%s %d %d", a[i].name, &a[i].id, &a[i].bj);
    for (int i = 0; i < 3; i++)
        printf("%s %d %d\n", a[i].name, a[i].id, a[i].bj);
    return 0;
}

4：结构体指针

struct student
{
    char name[32];
    int id;
    int age;
} a[3];

struct student *p = a;//结构体指针

int main(int argc, char const *argv[])
{
//     p->id=5;
//     p->age=6;
//     strcpy(p->name,"vnfv");
//     printf("%s %d %d\n",p->name,p->id,p->age);
    for(int i=0;i<3;i++)
    //scanf("%s %d %d",(p+i)->name,&(p+i)->id,&(p+i)->age);
    for(int i=0;i<3;i++)
   // printf("%s %d %d\n",(p+i)->name,(p+i)->id,(p+i)->age);
    printf("%s %d %d\n",p[i].name,p[i].age,p[i].id);
    return 0;
}

5：结构体指针的大小（sizeof）

sizeof(struct 结构体名);

或者

sizeof(结构体变量名);

结构体数组： 结构体类型大小*元素个数

sizoef(数组名);

字节对齐原则

例如：

struct stu

{

char a;

int c;  //结构体中最大的数据类型

char b;

}; //sizeof(struct stu) 等于12

struct stu

{

char a;

char b;

int c;

}; //sizeof(struct stu) 等于8

1. 第一个成员在相对于结构体变量起始位置偏移量offset为0的地址处（通俗点来说，就是第一个成员变量的地址与结构体起始位置的地址是相同的），以后每个成员按定义顺序依次存放在offset为该数据成员大小的整数倍的地方，只有double类型存放在4的整数倍的地方(比如int在32位机器位4字节，要从4的整数倍开始存储)。
2. 用结构体里面最大的数据类型的大小和8(32位系统和4)进行比较，按照字节数小的为单位开辟空间。

struct student//结构体中最大的数据类型为8字节
{
    float b;//4
    int a;//4
    short c;//2
    double d;//8
    char z;//1
};
int main(int argc, char const *argv[])
{
    printf("%ld\n", sizeof(struct student));
    return 0;
}

注释：64位操作系统指针为8字节，32位操作系统为4字节