二、分支与循环

分支语句

• if
• switch

循环语句

• while
• for
• do while

goto语句
 

什么是语句？

在C语言中由一个;号隔开的就是一个语句。

1.分支语句（选择结构）

1.1 if语句

if(表达式1)
语句1;
上面if语句中如果表达式结果为真那么执行语句1，如果为假则跳过。
我们可以设置分支
if(表达式1)
语句1;
else
语句2;
这段代码如果表达式1结果为假那么执行语句二。
同样我们可以有多个分支
if(表达式1)
语句1;
else if(表达式2)
语句2;
else
语句3;
如果表达式1的结果为假那么判断表达式2的语句，如果表达式2的语句为真则执行语句2，如果为假则执行语句3.

其中我们可以进行嵌套，例如

#include <stdio.h>
int main()
{
    int age = 20;
    if(age < 18)
        printf("未成年\n");
    else
    {
        if(age >= 18 && age <= 60)
            printf("成年\n");
        else
            printf("老年\n");
    }
    return 0;
}
    

如上我们就进行了一个简单的嵌套。if语句有很多的作用，可以版我们解决很多问题。

如果我们使用if语句需要执行多个代码，那么需要用{}括起来

int age = 20;
if(age < 18)
{
    printf("未成年\n");
    printf("不准谈恋爱\n");
}
    

注意：else会与最近的if匹配，如果为了避免这种错误需要加大括号

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 2;
    if (a == 1)
        if (b = 2)
            printf("haha");
    else
            printf("hehe");
    return 0;
}
    

如上述代码，输出结果为空，因为第8行的else与第7行的if匹配，导致表达式a==1为假后不再进行分支，如果要与第6行的if匹配需要为第7行的if加上大括号。

注意2

#include <stdio.h>
int main()
{
    int a = 0;
    if (a = 1)
            printf("haha\n");
    printf("%d\n", a);
    return 0;
}
    

上述代码输出结果为

1.2 switch语句

当我们输入一个数字判断星期几时，如果用if语句需要说明七种情况很麻烦，这时如果我们用switch语句可以简化很多。

#include <stdio.h>
int main()
{
    int a = 0;
    scanf(" %d", &a);
    switch (a)
    {
    case 1:
        printf("星期一\n");
    case 2:
        printf("星期二\n");
    case 3:
        printf("星期三\n");
    case 4:
        printf("星期四\n");
    case 5:
        printf("星期五\n");
    case 6:
        printf("星期六\n");
    case 7:
        printf("星期七\n");
    }
    return 0;
}
    

如上，switch规定一个整型表达式（switch括号里面的必须是一个整型），后面case后面跟着整型常量表达式（也必须为整型，不能是变量），当变量a和case后面的值对应时就会从此地方进入。

此时我们输入2会发现结果为

说明从case进入后会一直到switch语句最后才结束。
如果我们想中途推出，那需要加上break语句来跳出switch语句。

#include <stdio.h>
int main()
{
    int a = 0;
    scanf(" %d", &a);
    switch (a)
    {
    case 1:
        printf("星期一\n");
        break;
    case 2:
        printf("星期二\n");
        break;
    case 3:
        printf("星期三\n");
        break;
    case 4:
        printf("星期四\n");
        break;
    case 5:
        printf("星期五\n");
        break;
    case 6:
        printf("星期六\n");
        break;
    case 7:
        printf("星期七\n");
        break;
    }
    return 0;
}
    

这样我们在运行的时候就不会一直到switch语句最后才结束。

当我们输入8这种超出处理范围的数值时，此时运行不会得到任何结果。
如果我们想对超出的数据进行处理可以用default

#include <stdio.h>
int main()
{
    int a = 0;
    scanf(" %d", &a);
    switch (a)
    {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        printf("工作日\n");
        break;
    case 6:
    case 7:
        printf("休息日\n");
        break;
    default:
        printf("输入错误\n");
    }
    return 0;
}
    

这时我们输入超出处理范围的数据时就会直接提示输入错误。

关于case和default没有严格顺序控制，但是建议做好顺序。

2.循环语句

2.1 while

while(表达式)
循环语句;
当表达式的结果为真执行循环语句，知道表达式结果为假跳出循环。
比如一个简单的循环，在屏幕上打印一到十

#include <stdio.h>
int main()
{
    int i = 1;
    while(i <= 10)
    {
        printf("%d\n",i);
        i++;
    }
    return 0;
}
    

我们开始定义i=1，然后定义表达式只要i<=10就执行循环语句printf和i自增1，直到i自增到超过10结束循环。

在循环中，我们也可以用break跳出循环。

#include <stdio.h>
int main()
{
    int i = 1;
    while(i <= 10)
    {
        if(i==5)
            break;
        printf("%d\n",i);
        i++;
    }
    return 0;
}
    

这里我们在while循环中加了一个if语句，当i=5时执行break语句，这时输出结果为1到4，说明从5开始跳出循环不在执行。

循环中还有一个常用关键字continue，它的作用是终止当前循环后面的语句，然后直接跳到循环开始的判断部分。

#include <stdio.h>
int main()
{
    int i = 0;
    while(i < =10)
    {
        i++;
        if(i==5)
            continue;
        printf("%d\n",i);
    }
    return 0;
}
    

例如上面代码运行结果为1到10，除了5

getchar和putchar

getchar() 获取键盘上的一个字符
我们定义一个变量，然后就可以用变量存储getchar获得的字符
int a;
a = getchar();
和getchar()对应的是putchar()，putchar是在屏幕上输出一个字符
在上面代码后面输入
putchar(a);
就可以把刚才存到a中的字符输出（像printf一样）

当我们规定 ch=getchar() == EOF 才跳出循环时

#include <stdio.h>
int main()
{
    int i;
    while ((i=getchar()) != EOF)
    {
        putchar(i);
    }
    return 0;
}
    

输入缓冲区

当我们运以下代码时，在对数组进行输入时输入123456然后回车会发现直接返回取消，此时我们没有对ret进行任何赋值。

#include <stdio.h>
int main()
{
    char ret;
    int arr[10];
    scanf("%s", arr);
    ret = getchar();
    if (ret == 'Y')
    {
        printf("确认");
    }
    else
    {
        printf("取消");
    }
    return 0;
}
    

这是因为scanf和getchar都是输入函数，输入函数都会去一个输入缓冲区去取数据。首先运行scanf函数，然后scanf发现输入缓冲区没有东西，此时会等待输入数据。当我们输入123456然后回车的时候123456就被scanf取走，但是此时还有一个\n（因为scanf函数读取数据时到\n结束），然后getchar再去数据缓冲区发现有一个\n，所以直接取走\n，然后if判断返回取消。

如果想要正常运行那么需要清空输入缓冲区，我们可以再用一个getchar取走后面的\n。

但是如果我们输入arr时输入123456 ABC，此时又会返回取消。因为scanf取数据时只取了123456到空格时结束，然后第一个getchar取走了A，第二个getchar取走了B，接着返回取消。此时如果我们想清空输入缓冲区我们可以借助循环一直取走里面的数据，直到清空。

#include <stdio.h>
int main()
{
    char ret;
    char ch;
    int arr[10];
    scanf("%s", arr);
    while(ch=getchar()!='\n')
    {
        ;
    }
    ret = getchar();
    if (ret == 'Y')
    {
        printf("确认");
    }
    else
    {
        printf("取消");
    }
    return 0;
}
    

2.for循环

2.1语法

for(表达式1;表达式2;表达式3)
循环语句;

表达式1为初始部分，用于初始化循环变量，表达式2为条件判断部分，用于判断循环时候终止，表达式3为调整部分，用于循环条件的调整。

例：打印1-10

#include <stdio.h>
int main()
{
    for(int i=1;i<=10;i++)
        printf("%d\n",i);
    return 0;
}
    

for循环的条件和控制很清晰明了，所以使用次数多。

break和continue也可以用于for循环

2.2 for循环建议

1.不可再for循环内修改循环体，防止for循环失去控制。
2.建议for循环语句的循环控制变量的取值采用“前闭后开区间”写法。

2.3 for循环变种

变种1

#include <stdio.h>
int main()
{
    for(;;)
    {
        printf("hehe\n");
    }
    return 0;
}
    

当我们输入以下代码时会发现时死循环.

for循环的初始化，调整，判断都可以省略，但是for循环的判断部分如果被省略，那么判断条件就是;恒为正。

如果不熟悉建议不要省略。

#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    for(;i < 10;i++)
    {
        for(;j < 10;j++)
        {
            printf("hehe\n");
        }
    }
    return 0;
}
    

当我们运行以上代码时可能会认为打印100个hehe，但实际上只会打印10个。我们在外部声明了i和j两个变量的初始化为0，并且在for循环中省略了i和j的初始化。i初始为0进入循环，j也为0进入循环一直打印十次hehe，之后j=10跳出循环，i=2开始第二次循环。但是此时j没有初始化所以j还是等于10，因此直接跳出循环。以此类推只打印10次hehe。

变种2

#include 
int main()
{
    int x,y;
    for (x = 0,y = 0;x < 2 && y < 5; ++x, y++)
    {
        printf("hehe");
    }
    return 0;
}
    

这种循环用两个循环变量控制，也可以支持。

例题：请问以下代码循环几次

#include <stdio.h>
int main()
{
    int i = 0;
    int j = 0;
    for(i = 0,j = 0; k = 0; i++,k++)
    {
        k++;
    }
    return 0;
}
    

答案为0次，首先定义i和j的变量为0，然后for循环内初始化i和j。接下来判断语句是k=0是个赋值语句，而0为假所以循环没有执行直接跳出循环。

3. do...while()循环

3.1语法

do
{
表达式;
}
while(条件语句)

do...while()循环和其他循环有一点不同不管是否符合循环语句它都会执行一遍循环里面的表达式。

break和continue同样可以用于do...while循环

4.例题

顺数查找

在一个有序数列（1，2，3，4，5，6，7，8，9，10）中查找一个数的下标（比如说7）。
首先我们肯定会想到用循环从1到10挨个对比找到相应数字。

#include <stdio.h>
int main()
{
    int k=0;
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    for(int i=0;i<10;i++)
    {
        k=arr[i];
        if(k==7)
        {
            printf("下标为%d\n",k);
            break;
        }
    }
    return 0;
}
    

这种方法可以帮我们找到下标，但是需要挨个比对计算量太大效率降低，我们可以采用另一种方法提高效率。

二分查找法：首先我们去数列中间的数5，然后和要找的数比对，如果小于7再从5到10的范围内去中间的数，如果大于7则在1到5范围内取中间的数，以此类推直到找到相应的值。

#include <stdio.h>
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int k=sizeof(arr)/sizeof(arr[0]);
    int i=0;
    int j=k-1;
    int l=0;
    for(;;)
    {
        k=(j+i)/2;
        l=arr[k];
        if(l==7)
        {
            printf("下标为%d\n",k);
            break;
        }
        else if(l<7)
        {
            i=k;
        }
        else 
        {
            j=k;
        }
    }
    return 0;
}
    

求24和18两个数的最大公约数

首先我们肯定能想到先比较出大小，然后让较小的数递减，判断两个数同时除递减的数取余为0得到最大公约数。

#include <stdio.h>
int main()
{
    int m = 24;
    int n = 18;
    int k = n;
    while (k > 0)
    {
        k--;
        if (m % k == 0 && n % k == 0)
        {
            printf("最大公倍数为%d\n", k);
            break;
        }
    }
    return 0;
}
    

然后我们就可以得到最大公倍数，但是这种计算较为复杂，我们可以采用另一种辗转相除法降低复杂程度。

辗转相除法就是先用大的数m除小的数n取余得到一个数c，如果n再除c取余等于0，那么c就为最大公倍数，如果取余不为0，把n的值赋给m，c的值赋给n，再用m%n得c，n%c，以此类推直到n%c等于0.

#include <stdio.h>
int main()
{
    int m = 24;
    int n = 18;
    int c = 0;
    while (m % n)
    {
        c = m % n;
        if (n % c == 0)
        {
            printf("最大公倍数为%d\n", c);
            break;
        }
        m = n;
        n = c;
    }
    return 0;
}
    

求100-200之间的素数

素数的定义是只能被1和自己本身整除，所以我们首先会想到试除法。试除法就是找一个数a从2开始一直自增，用要判断的数一直除a,如果a自增到要判断的数-1还没有整除，那么这个数为素数。

#include <stdio.h>
int main()
{
    int i;
    int a;
    for (i = 100; i <= 200; i++)
    {
        for (a = 2; a < i; a++)
        {
            if (i % a == 0)
            {
                break;
            }
        }
        if (i == a)
        {
            printf("%d  ", i);
        }
    }
    return 0;
}
    

同样这种方法过于繁琐我们可以给它简化一下。我们发现一个数可以写成两个数相乘的形式，其中一个数一定小于或等于这个数的开平方，因此我们可以把a的范围缩小到i的开平方。

#include <stdio.h>
#include <math.h>
int main()
{
    int i;
    int a;
    for (i = 100; i <= 200; i++)
    {
        for (a = 2; a < sqrt(i); a++)
        {
            if (i % a == 0)
            {
                break;
            }
        }
        if (a >= sqrt(i))   //sqrt是数学库函数，所以要引用math
        {
            printf("%d  ", i);
        }
    }
    return 0;
}
    

在100-200中偶数是不可能是素数的，所以我们在第一个for循环中可以换成for(i=101;i<200;i+=2)来提升运算效率。

注意

注意求数组下标
当我们数组这样定义时
arr[5]={0,1,2,3,4};
我们可以用sizeof(arr)/sizeof(arr[0])-1求得最后一位4的下标。
但是如果我们这样定义
arr[]=abcdefg;
我们想求g的下标则不能-1，因为这个数组不完整，它最后一位还有一个/0，这一位也算在内，所以如果想求g的下标需要-2.

注意==不能用来比较两个字符串是否相等应该用库函数strcmp。
strcmp(字符串1,字符串2)==1;

#include <stdio.h>
int MAX(int i,int j)
{
    if(i >j )
    return i;
    else
    return j;
}
int main()
{
    int num1 = 10;
    int num2 = 15;
    int max=MAX(num1,num2);
    printf("%d\n",max);
    return 0;
}

#include <stdio.h>
void Swap(int x,int y)
{
    int tmp = 0;
    tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int num1 = 7;
    int num2 = 10;
    Swap(num1,num2);
    printf("%d %d\n",num1,num2);
}  

#include <stdio.h>
void Swap(int*x,int*y)
{
    int tmp = 0;
    tmp = *x;   //*是解引用操作符，表示地址中的值
    *x = *y;
    *y = tmp;
}
int main()
{
    int num1 = 7;
    int num2 = 10;
    Swap(&num1,&num2);    //将地址传给函数
    printf("%d %d\n",num1,num2);
}

#include <stdio.h>
int chan(int arr[], int b)
{
    int a = 0;
    int j = 0;
    int l = sizeof(arr) / sizeof(arr[0]) - 1;
    while (l >= a)
    {
        j = (a + l) / 2;
        if (arr[j] == b)
        {
            return j;
        }
        else if (arr[j] < b)
        {
            a = j + 1;
        }
        else
        {
            l = j - 1;
        }
    }
    return -1;
}
int main()
{
    int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
    int k = 8;
    int rel = chan(arr, k);
    if (rel == -1)
    {
        printf("找不到");
    }
    else
    {
        printf("找到了下标为：%d", rel);
    }
    return 0;
}

#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
}

#include <stdio.h>
int ADD(int,int);  //函数声明
int main()
{
    int a = 1;
    int b = 2;
    int c = ADD(a, b);    //函数调用
    printf("%d", c);
    return 0;
}
int ADD(int x, int y)    //函数定义
{
    int z = x + y;
    return z;
}

#include <stdio.h>
int main()
{
    printf("hehe\n");
    main();
    return 0;
}

#include <stdio.h>
void print(int n)
{
    if (n > 9)
    {
        print(n/10);
    }
    printf("%d  ",  n % 10);
}
int main()
{
    int num = 0;
    scanf("%d", &num);
    print(num);
    return 0;
}

#include <stdio.h>
int mystr(char* str)
{
    if (*str != '\0')
        return 1 + mystr(str + 1);
    else
        return 0;
}
int main()
{
    char arr[] = "bit";
    int len = mystr(arr);
    printf("len=%d\n", len);
    return 0;
}

#include <stdio.h>
int fib(int x)
{
    if (x <= 2)
        return 1;
    else
        return fbnq(x - 1) + fbnq(x - 2);
}
int main()
{
    int n = 0;
    int m = 0;
    scanf("%d", &n);
    m = fib(n);
    printf("第%d个斐波那契数列为%d\n", n, m);
    return 0;
} 

#include <stdio.h>
int fib(int x)
{
    int a = 1;
    int b = 1;
    int c = 1;    //这里c取1是因为下面判断x小于等于2的时候返回1
    while (x > 2)
    {
        c = a + b;
        a = b;
        b = c;
        x--;
    }
    return c;
}
int main()
{
    int n = 0;
    int m = 0;
    scanf("%d", &n);
    m = fib(n);
    printf("第%d个斐波那契数列为%d\n", n, m);
    return 0;
}