示例：假设人口总数为13亿，按每年2%增长，计算从现在开始10年内的人口的数量

 流程图：

2：计算1-1/4+1/7-1/10+1/13-1/16+...的和，直到某一项的绝对值小于10^-6为止

代码：

 流程图：

二：for语句实现循环结构

执行过程如下：

for(1;2条件；3）

{语句4；}5

先 1>>>2(真）>>>4>>3

3>>>2(真）>>>4

3>>>2(真）>>>4

........

3>>>2(假）>>>6

示例：1,输入一个正整数n,求sum+1+2+3+……+n的值

代码：

流程图： 

其中：1：循环变量赋初值i=1

2：循环条件为i<=n

3:循环变量增量i++

4：循环体语句sum=sum+i

2,输入一个正整数n,求n!(n的阶层）

代码：

流程图： 

其中：1：循环变量赋初值i=1

2:循环条件为i<=n

3:循环变量增量：i++

4:循环语句：factorial=factori *i

2:for语句的一般形式中省略表达式1

格式如下

for(；表达式2；表达式3)

循环体语句

说明：省略表达式1时，可以将循环变量赋初值放在for之前。注意此时不能省略第一个“；”

for(i=1;i<=n;i++)           

  sum=sum+i;=1

等价于

i=1；

for(;i<=n;i++)

sum=sum+i;

3:for语句的一般形式省略表达式2

格式如下

for(表达式1；；表达式3)

循环体语句；

说明：省略表达式2时，表示不对循环进行控制，这时没有其他处理的话，会形成死循环。应避免这样使用for结构

4：

for语句的一般形式中省略表达式3

格式如下

for(表达式1；表达式2；)

循环体语句

说明：省略表达式3时，可以在循环体语句加入修改循环变量的值和语句

for（i=1;i<=n;i++)

factorial=fatorial*i;

等价于

for(i=1;i<=n)

{factorial=factorial*i;

i++;}

5:for语句的一般形式表达式1和表达式3也可以是逗号表达式

sum=0

for(i=1;i<=n;i++)           

  sum=sum+i;

等价于

for(sum=0,i=1;i<=n;i++)           

  sum=sum+i;

表达式sum=0,i=1为逗号表达式

6：for语句的一般形式中表达式2的只要非0，就执行循环体

for（；ch=getchar()!='\n';)

printf("%c",ch)

7:for语句的一般形式中循环体语句可以省略

for(i=1;i<=n;i++)           

  sum=sum+i；

等价于

for(i=1;i<=n;  sum=sum+i;i++)

循环体语句sum+sum；放入表达式3中，与i++构成一个逗号表达式，此时循环体语句实际为一个空语句“；”

三：for语句使用示例

1：代码：编写程序，输入一个整数n,计算1-1/4+1/7-1/10+1/13-1/16+...d的值前n项和

流程图： 

2：代码：编写程序，输入10个数，输出其中的最大值

 流程图：

 如果不把第一个数赋给max,则代码可修改为

#include<stdio.h>
int main()
{
 int i;
 float x, max;
 
 for(i=1;i<=9;i++)
 {
  printf("请输入第%d个数：", i );
  scanf_s("%f", &x);
  if (i == 1)
   max = x;
  else
   if (x > max)
    max = x;
 }
 printf("10个数的最大值：%.0f", max);
}

3:代码：编写程序，输出所有的水仙花数

 流程图：

 4:编写程序，由键盘输入一个正整数，判断该数是否为完数

代码：

 流程图：

 5：统计由键盘中输入的若干字符中，大写英文字母，小写英文字母，数字字符和其他字符的个数

代码：

流程图：

说明：（1）在for循环中，每次读入一个字符，根据字符的种类，选择不同的分支执行相应相应的运算。循环共执行10次，读入10个字符，相应的计数变量进行了计数

（2）程序中使用字符输入函数getchar()读入字符，使用多分支if结构实现分支，用逻辑表达式判断字符的种类

6：输入一行小写字母，将他们转换为大写字母

流程图： 

 若省略计数变量i,即for语句只有表达式2，有表达式1和表达式3，运行结果与上述程序相同

 7：由键盘输入3个，将其组合成一个整型数并输出

流程图： 说明：程序中使用的是在for循环语句中读入字符，所以键盘输入3位数字字符时，应连续输入，数字字符之间不能出现空格，如果输入空格或者回车符，由于%c表示要读入一个字符，而空格本身也是一个字符，因次会被作为输入字符

8：编写程序，由键盘输入一个正整数，判断是否为素数

素数的定义：素数只能被1和他本身整除；1不是素数，2是素数

 流程图：

二：使用while语句实现循环结构

5.3.1 while语句的基本语法

while（表达式）

循环体

如 

1：while循环使用示例

计算sum=1+2+3+4+...+100的和

 流程图：

 2：输入一个正整数n,计算n！

 流程图

3：由键盘读入一个字符，只要输入的不是回车符就继续循环

流程图

 说明：程序中while语句的条件

（ch=gechar())!='\n'

不能写成ch=getchar()!='\n'

(1)循环体为一条完整的if语句，若有多条语句时，必须使用复合语

三：使用do-while语句实现循环结构

do-while一般形式为

do

循环体

while(表达式）

步骤：

 1：do-while循环使用示例

使用do-while语句计算sum=1+2+3+4+...+100的和

流程图： 

使用do-while语句应注意几点

（1）在do之后不能出现有语句结束符“；”，因为该语句还没有结束

（2）在while（表达式）之后必须有语句结束符“；”，表示do-while语句到此结束

（3）在循环体中必须有改变循环条件的语句，否则会出现死循环

2：求两个自然数的最大公约数和最小公倍数

 流程图：

 3：输入一个整数，统计该数的位数

 流程图：

 四：改变循环结构的跳转语句

许多时候当循环结构中出现多个循环条件时，要求当某个条件满足时会立即结束循环，或者循环结构中根据条件会跳过某些语句继续循环，这就要在循环结构中配合使用

break和continue

1:break语句：当break语句用于循环语句中时，可使程序终止循环而转去执行循环语句的后继语句。通常break语句总是于if语句一起配合使用，即满足条件时跳出循环。

 流程图：

编写程序，由键盘输入一个正整数，判断其是否为素数

 流程图：

说明：（1）程序中结束for循环的条件有两个：一是i>m;二是break语句

（2）若i>m,说明for循环正常结束，则n一定是素数

（3）若遇到break语句，说明循环中条件n%i==0成立，n能被某个i整除，执行break语句推出循环，此时i<=m，n一定不是素数

问：从键盘输入一批学生的成绩（以负数作为结束标志），计算平均分，并统计不及格成绩的个数

     分析：程序要求输入一批学生的成绩，没有给出学生的具体数目，这样的问题 常常使用形如下面的一段程序代码实现:

while(1)

{...}

虽然循环的条件永远成立，所以在循环体中需要搭配”if（条件）break;"的语句，使循环在满足条件的情况下结束

流程图; 

2:continue语句

continue语句的作用是跳过循环体continue后面的语句，继续下一个循环。continue语句只能用在循环语句中，常与if语句一起使用

如：把1~100之间能被7整除的数，以每行5个的形式在屏幕上输出

流程图： 

注意：continue语句与break语句有着本质的区别：continue语句只是结束本次循环，并不终止整个循环的执行；而break语句的作用是强制终止整个循环程序

 流程图：

主要注意：

return      结束main方法

break       结束整个循环
continue    结束本次循环，进行下次循环

3:goto语句

除了前面3种循环控制语句，即for循环语句，while循环语句，do-while循环语句之外，在C语言中，还有一种可以实现循环控制的语句，即goto语句。

goto语句的一般形式如下：

goto 语句标号

说明：语句标号是一个有效的标识符，使用时在语句标号的后面跟一个“：”出现在函数中某语句的前面。程序执行到goto语句时，会控制跳转到该语句标号处，达到控制循环的目的。

例子：使用goto语句计算sum=1+2+3+4+5+...+100的和

代码：#include<stdio.h>
int main()
{
    int i, sum;
    i = 1; 
    sum = 0;
loop:if(i<=100)
{
    sum = sum + i;
    i = i + 1;
    goto loop;
}printf("sum=%d\n", sum);
}

 流程图：

注意：语句标号必须与goto语句处于同一个函数中，通常goto语句与if语句连用实现循环控制。在大型程序中由于goto语句存在不合理的使用，会使程序结构变坏，所以在结构化程序设计中，不建议使用goto语句

四：循环嵌套

使用for语句，while语句及do-while语句相互嵌套，构成的嵌套结构有以下几种

（1）for语句中嵌套for语句

for()

{...

for()

{...}

}

(2)for语句中嵌套while语句

for()

{...

while()

{...}

}

(3)while语句嵌套while语句

while（）

{...

while()

{...}

...

}

(4)do-while语句中嵌套for语句

do

{...

for（）

{...}

...

}while();

(5)do-while语句嵌套do-while语句                                            （6)while语句嵌套do-while语句

do                                                                                              while()

{...                                                                                              {...

do                                                                                                do

{...                                                                                               {...

}while();                                                                                       }while（）；

...                                                                                                  ...

}while();                                                                                     }

使用循环嵌套时，注意以下几点：

（1）外循环执行一次时，内循环要执行一轮。即外循环执行一次，内循环一直执行到条件不满足时为一轮；在执行外循环一次，内循环有一直执行到不满足时为第2轮；如此重复执行，直到外循环条件不满足时，整个循环嵌套结束

（2）循环嵌套格式中的内外循环体不允许出现交叉，即外循环要完全包容内循环

（3）循环嵌套时，内循环体中break语句和continue语句时，只影响包含他们的内循环，与外循环无关。

例子：求1！+2！+3！+...+10!

代码：#include<stdio.h>
int main()
{
    int i, j;
    double factorial, s = 10;
    for(i=1;i<=10;i++)
    {
        factorial = 1;
        for (j = 1; j <= i; j++)
        {
            factorial = factorial * j;
        }
        s = s + factorial;
    }
    printf("1!+2!+3!+...+10!=%.0f\n", s);
}

流程图： 

说明：本例中 外循环每执行一次，累加一项factorial，而factorial的值i！由内循环执行一轮后得到；外循环共重复10次，每一次由内循环执行一轮后得到的一个阶乘值

示例1：编写代码，输出乘法口诀表

代码：#include<stdio.h>
int main()
{
    int i,j;
    for(i=1;i<=9;i++)
    {
        for (j = 1; j <= i; j++)
            printf("%d*%d=%d\t", j, i, j * i);
        printf("\n");
    }
}

流程图： 

示例2：求100以内的素数，要求每行输出10个

代码 ：

#include<stdio.h>
#include<math.h>
int main()
{
    int i, n, k, count = 0;
    n = 2;
    while (n < 100)
    {
        k = sqrt(n);
        for (i = 2; i <= k; i++)

        {
            if (n % i == 0)

            {
                break;
            }
        }

        if (i > k)
        {
            printf("%4d", n);
            if (++count % 10 == 0)

            {
                printf("\n");
            }

        }
        n++;
    }
    return 0;
}

流程图： 

示例3：将10~20之间的正整数分解质因数。例如将12可分解2*2*3

代码：#include<stdio.h>
#include<math.h>
int main()
{
    int i, n, m;
    for(m=10;m<=20;m++)
    {
        n = m, i = 2;
        printf("%d=", n);
        do
        {
            if (n % i == 0)
            {
                printf("%d*", i);
                n = n / i;
            }
            else
                i++;
        } while (n != i);
        printf("%d\n", n);
    }
}

流程图： 

五：典型算数举例 

1：递推法

示例（1）：猴子吃桃问题：猴子第一天摘下若干个桃子，吃了一半，还觉得不过瘾，又多吃了一个，第2天早上又将剩下的桃子吃掉一半，又多吃了一个，以后每天早上都吃了前一天剩下的一半零一个。到第10天，只剩下一个桃子了，问第一天摘了多少桃子

代码：#include<stdio.h>
int main()
{
 int day, d1, d2;
 day = 9;
 d2 = 1;
 do
 {
  d1 = (d2 + 1) * 2;
  d2 = d1;
  --day;
 } while (day > 0);
 printf("第一天摘了%d\n", d1);
}

流程图： 示例（2）求sin（x)=x-x^3/3!+x^5/5!-x^7/7!+...的近似值，要求精确到10^-6

应用循环结构实现算法如下：

do

{n=n+1;

fz=-fz*x*x;

fm=fm*(2*n-2)*(2*n-1);

sinx=sinx+fz/fm;

}while(fabs(fz/fm)>1e-6);

 代码：#include<stdio.h>
#include<math.h>
#define eps 1e-6
int main()
{
 int n = 1;
 float x;
 double fz, fm =1, sinx;
 printf("输入x的值：");
 scanf_s("%f", &x);
 fz = x;
 sinx = x;
 do
 {
  n = n + 1;
  fz = -fz * x * x;
  fm = fm * (2 * n - 2) * (2 * n - 1);
  sinx = sinx + fz / fm;
 } while (fabs(fz / fm) > eps);
 printf("sin(%f)=%0.6f\n", x, sinx);
 printf("sin(%f)=%0.6f\n", x, sin(x));
}

流程图： 

 2：迭代法

示例：用牛顿迭代法求方程2x^3-4x^2+3x-6=0在1.0附近的根

代码：#include<stdio.h>
#include<math.h>
#define eps 1e-6
int main()
{
 float x1, x0, f, f1;
 x1 = 1.0;
 do
 {
  x0 = x1;
  f = ((2 * x0 - 4) * x0 + 3) * x0 - 6;
  f1 = (6 * x0 - 8) * x0 + 3;
  x1 = x0 - f / f1;
 } while (fabs(x1 - x0) > eps);
 printf("%6.2f", x1);
}

流程图： 3：穷举法（列举法）

示例（1）：36块砖，36人搬，男搬4，女搬3，两个小孩抬一砖，要求一次搬完，问男，女，小孩各多少。

代码：#include<stdio.h>
int main()
{
 int men, women, child;
 for(men=0;men<=9;men++)
 
  for (women = 0; women <= 12; women++)
  {
   child = 36 - men - women;
   if (men * 4 + women * 3 + child * 0.5 == 36)
    printf("男：%d，女：%d,小孩：%d\n", men, women, child);
  }
 
}

 流程图：

 示例（2）：编写程序，判断由1，2，3，4四个数字能组成多少个互不相同且无重复数字的三位数？输出这些数

代码：#include<stdio.h>
int main()
{
    int i, j, k, n = 0;
    for(i=1;i<5;i++)
        for(j=1;j<5;j++)
            for(k=1;k<5;k++)
                if(i!=k&&i!=j&&j!=k)
                {
                    printf("%d%d%d\t", i, j, k);
                    if (++n % 5 == 0)
                        printf("\n");
                }
    printf("\n共有：%d\n", n);
}

流程图： 穷举法的解题思路是：在一个集合内对每个元素一一测试

六：循环程序设计示例

示例1： 图形

代码：#include<stdio.h>
int main()
{
    int i, j;
    for(i=1;i<=5;i++)
    {
        for (j = 1; j <= 20 - i; j++)
            printf("");
        for (j = 1; j <= 2 * i - 1; j++)
            printf("*");
        printf("\n");
    }
}

流程图： 

示例2：由计算机随机产生一个10~80之间的数据，然后由用户进行猜数，在五次之内猜中则成功，否则给出大小提示。猜5次之后结束程序

代码：#include<stdio.h>
#include<stdlib.h>
int main()
{
    int m, n,count = 0;
    m = rand() % (80 - 10 + 1) + 10;
    printf("请输入一个10-80之间的整数：");
    while(1)
    {
        scanf_s("%d", &n);
        count++;
        if (m == n)
        {
            printf("答对了，亲\n");
            break;
        }
        else if (m > n && count < 5)
            printf("猜小了哦，亲");
        else if (m < n && count < 5)
            printf("猜大了哦，亲");
        if(count==5)
        {
            printf("没有机会了哦，亲\n这个数是：%d,游戏结束！\n", m);
        }
    }
}
 流程图：

 示例3:编写程序输出100~100内的回文素数。回文素数是指即是回文数同时也是素数的整数。如131即是回文数也是素数

代码：#include<stdio.h>
#include<math.h>
int main()
{
    int x, i, j = 0, k = 0, n;
    for(x=100;x<1000;x++)
    {
        k = sqrt(x);
        for (i = 2; i <= k; i++)
            if (x % i == 0)
                break;
        if(i>k)
        {
            k = x;
            n = 0;
            while(k>0)
            {
                n = n * 10 + k % 10;
                k /= 10;
            }
            if(x==n)
            {
                printf("%d\t", x);
                if (++j % 5 == 0)
                    printf("\n");
            }
        }
    }
}

 流程图：

示例4：在所有三位整数中找出平方数中有连续的三位数是该数的本身的数。如250的平方是62500，250便是所要找的一个满足条件的三位整数

代码： 

#include<stdio.h>
int main()
{
    int x, t;
    printf("i\tpower\n");
    for(x=100;x<1000;x++)
    {
        t = x * x;
        while (t != 0)
        {
            if (x == t % 1000)
            {
                printf("%d\t%d\n", x, x * x);
                break;
            }
            else
                t = t / 10;
        }
    }
}

流程图：