三种循环结构语句
1.for循环
格式：
	for(初始化语句1; 判断语句2; 步进语句3){
        循环代码4
	}

执行流程：
	先执行1初始化语句
	执行2判断语句,如果判断结果是true
	执行4循环代码
	执行3步进语句
		继续回到2 4 3 2 4 3 
		如果判断结果是false,代表循环结束
注意：
	初始化语句只在第一次循环中执行，之后不再执行

代码
public static void main(String[] args) {
        /*
        判断0-10的奇偶数
         */
        //偶数：能够被2整除的数字称为偶数
        // 0 是一个特殊的偶数
        for(int i=0;i<=10;i++){
            if (i%2 == 0){
                System.out.println(i+"是偶数");
            }else {
                System.out.println(i+"是奇数");
            }
        }
    }

console
0是偶数
1是奇数
2是偶数
3是奇数
4是偶数
5是奇数
6是偶数
7是奇数
8是偶数
9是奇数
10是偶数

2.while循环
格式:
	初始化语句1;
	while(判断语句2){
        循环代码3;
        步进语句4;
	}

执行流程:
	1 初始化语句
	2 执行判断语句,如果是true就执行大括号里面的代码,如果是false就结束循环
	3 循环代码
	4 步进语句
	
	再次循环执行2判断语句

代码
public static void main(String[] args) {
        /*
        求1-100的累加和
         */
        int x = 1;
        int sum = 0;
        while (x<=100){
            sum += x;
            x++;
        }
        System.out.println("1-100的累加和为："+sum);
    }

console
1-100的累加和为：5050

3.do-while循环
格式:
	初始化语句1;
	do{
        循环语句2;
        步进语句3;
	}while(判断语句4);

执行流程:
	1 初始化语句
	2 循环语句
	3 步进语句
	4 判断语句 , 如果判断的结果是true就继续循环,如果判断的结果是false就结束循环
注意：
	do-while循环是先执行后判断，不管条件是否满足至少执行一次

代码
public static void main(String[] args) {
        /*
        输出1-10的和
         */
        int a = 1;
        int sum = 0;
        do {
            sum += a;
            a++;
        }while (a<=10);
        System.out.println("1-10的和为："+sum);
    }

console
1-10的和为：55

三种循环的使用场景
三种循环结构均可实现相应的功能，按照实际需要选择更为简便的形式。以下为使用场景的总结：
	1.明确循环次数的时候：建议使用for循环	
	2.不明确循环次数的时候：建议使用while循环
	3.do...while循环比较特殊，它先执行循环体，然后根据判断条件决定是否再次执行循环，即do...while至少执行一次循环

循环嵌套
代码1
public static void main(String[] args) {
        /*
        循环嵌套：
            外层循环执行1次,内存循环执行一圈
         */
        /*
        循环出从0点0分-23点59分
         */
        //遍历小时
        for (int i=0; i<24; i++){
            //遍历分钟
            for (int j=0; j<60; j++){
                System.out.println(i + "点" + j + "分");
            }
        }

console
0点0分
0点1分
0点2分
...
23点57分
23点58分
23点59分

代码2
public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            System.out.println("你是第" + i + "位顾客");
            while (true) {
                System.out.println("请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买");
                Scanner sc = new Scanner(System.in);
                int a = sc.nextInt();
                if (a == 1) {
                    System.out.println("您购买的是水果");
                } else if (a == 2) {
                    System.out.println("你购买的是蔬菜");
                } else if (a == 3) {
                    System.out.println("您购买的是饮品");
                } else if (a == 4) {
                    break;
                } else {
                    System.out.println("您输入的指令有错误");
                }
            }
        }
    }

console
你是第1位顾客
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
1
您购买的是水果
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
2
你购买的是蔬菜
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
4
你是第2位顾客
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
3
您购买的是饮品
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
4
你是第3位顾客
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
2
你购买的是蔬菜
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
...
你是第9位顾客
请选择你想要购买的商品：1.水果 2.蔬菜 3.饮料 4.结束购买
2
你购买的是蔬菜

两种死循环的写法
1.while(true){...}
2.for(;;){...}

概念

在C语言程序中，一共有三种程序结构：顺序结构、选择结构(分支结构)、循环结构；

顺序结构，从头到尾一句接着一句的执行下来，直到执行完最后一句；

选择结构，到某个节点后，会根据一次判断的结果来决定之后向哪一个分支方向执行；

循环结构，循环结构有一个循环体，循环体里是一段代码。对于循环结构来说，关键在于根据判断的结果，来决定循环体执行多少次。C语言循环控制语句是一个基于C语言的编程语句，该语句主要有while循环语句、do-while循环语句和for循环语句来实现循环结构。

 

但是三种结构并不是彼此孤立 循环中可以有顺序, 选择(分支).  顺序中可以有选择,可以有循环. 选择中也可以有顺序有循环. 一段程序代码往往是这三者相互结合组成的.

 

1.顺序结构

 C语言的顺序结构顾名思义, 就是程序自上而下执行, 没有分支,也没有循环.

 

#include <stdio.h>

int main(){
    int a = 3, b = 2;
    int sum = a+b;
    printf("a+b=%d\n", sum);    //输出a+b的和
    return 0;
}


像上述代码, 程序顺序执行求和a+b并输出, 没有循环也没有分支, 所以上述代码就是一个顺序结构.

 



2.选择(分支)结构

C语言选择结构用于判断给定的条件，根据判断的结果来控制程序的流程。

在C语言中, 选择结构有两种: 1. if-else语句,  2. switch-case语句;

1) if-else 语句

写法:

 

if(条件1){
    //满足条件1执行此代码块
    ...
}else if(条件2){
    //不满足条件1, 满足条件2执行此代码块
    ...
}else{
    //即不满足条件1也不满足条件2 执行此代码块
    ...
}

举个栗子, 成绩评级.

 

#include <stdio.h>

int main(){
    int score = 78; //模拟输入成绩

    if (score >= 90){  //成绩 大于90 A
        printf("A");
    }else if(score >= 80 && score < 90){ // 80-89 B
        printf("B");
    }else if(score >= 70 && score < 80){ // 70-79 C
        printf("C");
    }else if(score >= 60 && score < 70){ // 60-69 D
        printf("D");
    }else{  //小于60 E
        printf("E");
    }

    return 0;
}


 

else if 可以有0个或多个,  else 只能有0个或1个.

如果我们只需判断学生是否及各, 那么我们就可以这样写:

 

if (score >= 60){
    printf("及格");
}else{
    printf("不及格");
}


当然也可以只有if() 没有else ,  只有if() 和 else if ()没有else.

2)switch-case 语句

在C语言中, 第二种分支结构就是switch-case, 只是用的地方不太多, 因为if语句可以轻松替代switch语句, 只是结构上没switch那么清晰.

语法:

 

switch (变量或表达式){
    case 常量表达式1: 语句块1; break;
    case 常量表达式2: 语句块2; break;
    ......
    case 常量表达式n: 语句块n; break;
    default: 语句块n+1; break;
}

还是成绩评级的栗子:

 

#include <stdio.h>

int main(){
    int score = 78;  //模拟输入
    
    switch(score / 10){ //case匹配的数据就是score/10的结果  
        case 10: 
        case 9: printf("A"); break;
        case 8: printf("B"); break;
        case 7: printf("C"); break;
        case 6: printf("D"); break;
        default: printf("E"); break;
    }

    return 0;
}

score/10 得到的整数就是那个阶段的成绩, 我们会发现case 10: 也就是100分匹配后面没有任何的操作, 最主要的是, 没有break;

在switch语句中, 如果case匹配到了语句, 那么后面的语句都会执行知道出现第一个break, 或者执行完成.

如果我们将上面代码中的break全部去掉.score还是78, 那么输出就会变成 CDE, 也就是匹配到7 然后输出7之后的所有语句,知道碰到break;

default相当于else, 其他所有不匹配的情况, 因为一般是放在最下面, 所以default后面的break可以不写.

 

重点:switch的条件只能是整型和字符型(其实就是字符的ascii码)或者这些类型的表达式,case匹配的只能是整型或者字符型常量或者这两个类型的常量表达式, 也就是case不能匹配变量.

 

3.循环结构

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。

在C语言中有三种循环结构: for循环, while循环, do-while循环.

1) for循环

写法:

 

for(表达式1; 表达式2; 表达式3){
    循环体;
}

语句1：初值表达式，常用于在循环开始前为循环变量赋初值

语句2：循环控制逻辑表达式，控制循环执行和结束的条件

语句3：循环变量修改表达式，常用于修改循环变量,使得结果趋向于循环结束条件.

举个栗子:

循环输出10个"hello world!!!"

 

#include <stdio.h>

int main(){
    int i;
    for (i = 1; i <= 10; i++){ //循环10次, i++为 i自增长1
        printf("hello world!!!\n");
    }
    return 0;
}


上诉for循环的执行过程:

1.执行表达式1, i = 1, 只执行一遍.

2. 执行表达式2, 判断 i <=10

3.如果表达式2成立, 执行循环体  { printf("hello world!!!\n"); } 否则执行退出循环, 后续步骤都不执行.

4.执行完成循环体后,执行表达式3, i++, i的值自动增长1. 回到步骤2去判断.

 

for循环中的三个表达式都可以为空, 但是一定要写两个分号也就是 for( ; ; ) 这样就代表无限循环, 也就是死循环.不过一般不会这样用.

 

而for循环常用的是对数组的操作,所以初始值一般是0.

 

int i;
int Stu[10] = {99, 87, 76, 59, 73, 45, 99, 39, 88, 19}; //班级10个学生的成绩

for(i = 0; i < 10; i++){    //循环10次, 0~9
    printf("学号为:%d, 成绩为: %d\n", i+1, Stu[i]);   //数组下标从0开始
}

其实可以发现, 正常的for循环可以很清晰的明白for循环的循环次数.

 

所以在你很清晰明白这次循环需要循环多少次的时候推荐使用for循环.

 

2)  while 循环

while循环的语法简单易懂

 

 while(表达式){
        语句块
    }

执行过程: 执行表达式, 如果成立执行语句块, 否则退出循环.

 

while循环也可以和for循环互换.

 

//for -> while
int i = 0;
while (i < 10){
    //循环体
    i++;
}
//while -> for
for (;l < r;){
}


for->while: 没有for循环那么清晰明了的知道循环次数.

while->for: 没有while循环那么简单易懂了.

所以while循环的一般用法是我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候使用.

举个例子: 二分查找

 

#include <stdio.h> 
 
int main(){  
    int a[10] = {12, 32, 34, 55, 76, 89, 99, 123, 345, 1234}; //递增的数组 
    int l = 0, r = 9, mid; 
    int res = 345;  //查找的目标 
    //二分查找位置 
    while(l <= r){ 
        mid = (l+r)/2; 
        if (res == a[mid]){  //找到了输出位置, 并退出循环. 
            printf("位置: %d\n", mid+1); break; 
        }else if(res < a[mid]){  
            r = mid-1; 
        }else{   
            l = mid+1; 
        } 
    } 
    return 0; 
} 


我们只看while循环的内容, while(l<=r)  也就是当l>r时循环退出.

 

 

 

和for循环不同的是, 我们并不清楚程序在什么时候会退出, l和r在循环中是在不断变换的.这种情况使用while循环是个不错的选择.

 

3) do-while循环

 

do{
    循环体
}while(表达式);


和while循环不同的是,do-while循环是先执行一遍循环体,再判断是否满足表达式.

 

注意: do-while循环最后是有一个分号结尾的.

do-while循环的用处也就在先执行一遍循环体再判断, 那么如果我们需要判断的内容必须要执行一遍循环体才能知道的话,那么就可以使用do-while循环.

举个例子:

 

#include <stdio.h>

int main(){
    int t;
    int res = 89;
    do{
        printf("请输入一个数字,输入0退出游戏:");
        scanf("%d", &t);
        if(t == res){
            printf("猜对了!\n");
        }else if (t > res){
            printf("太大\n");
        }else{
            printf("太小\n");
        }

    }while(t != 0);
    return 0;
}


虽然这个例子bug很多, 但是我们可以清晰的理解do-while循环的不同, 我们一开始并不清楚t的值, 当我们执行完循环体后才知道t的值,然后做判断.

 

 

三大循环总结:

for 循环: 在你很清晰明白这次循环需要循环多少次的时候推荐使用.

while循环: 在我们不太清楚循环在什么时候结束, 并且我们也不关心具体的循环次数的时候推荐使用.

do-while循环: 如果我们需要判断的内容必须要执行一遍循环体才能知道的话推荐使用.

 

 

 

LABVIEW中有两种循环结构，分别是FOR循环while循环。它们的区别是for循环在使用时要预先指定循环次数，当循环体运行了指定次数的循环后自动退出；而while循环则无须指定循环次数，只要满足循环退出的条件便退出相应的循环，如果无法满足循环退出的条件，则循环持续下去。

 For循环

For循环位于“函数选板”→“编程”→“结构”的子选板中，for循环并不立即出现，而是以表示for循环的小图标出现，用户可以从中拖拽出放在程序框图上，自行调整大小和定位于适当位置。



 

如图所示，for循环有两个端口，总线接线端（输入端）和计数接线端（输出端）。输入端指定要循环的次数，该端子的数据表示类型的是32位有符号整数，若输入7.5，则保存为7，即把浮点数直接取整，输入端不能为负数和0。输出端显示当前的循环次数，也是32位有符号整数，默认从0开始，依次增加1，即N-1表示的是第N次循环。

   判断最大值与最小值可以使用最大值和最小值函数。此循环中包含时间延迟，以便用户可以随着for循环的运行而看清数值的更新。具体操作如下：

1、在“函数”选板上选择“编程”→“结构”→“for循环”函数，放置到程序框图中，拖动出适当大小的矩形框。

2、拖动两个“随机数”函数，一个“最大值与最小值”函数，四个“数值常量”函数和一个“时间延时”函数，并进行重新命名。特殊说明：大值和小值得函数应改为输出函数。



 

3、运行结果如下



 

While循环

同for循环，while循环也需要自行拖到来调整大小和定位适当的位置。同FOR循环不同的是while循环无须指定循环测次数。

While循环重复执行代码片段直到条件接线端接收到某一特定的布尔值为止。While循环有两个端子：计数接线端（输出端）和条件接线端（输入端），输出端记录循环已经执行的次数；输入端的设置分两种情况：条件为真时继续执行和条件为真时停止执行



 

   While循环是执行后再检查条件端子，而for是执行前就检查是否符合条件，所以while循环至少执行一次。

1、程序结构

程序分三种结构：顺序结构、分支结构、循环结构；

2、循环结构

概述：循环结构是程序中一种很重要的结构。其特点是，在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。

循环条件：循环体退出的主要依据，当条件成立时，执行循环体的语句，当条件不成立时，退出循环体。
循环体：循环过程中，重复执行的条件。
3、while循环



while循环条件的格式：
while(条件){


循环体;

}

语句含义：当条件成立时，执行循环体内的语句；然后，再次判断条件，直到条件不成立，就结束循环。
使用场景：
1).在某个范围内查找满足条件的值；
2).在特定情况下，需要用死循环，就可使用while。

使用注意：
1).条件语句中，任何数值都有真假性，条件语句中如果是非零整数即为真；

2).如果while语句后面只有一条语句，那么可以省略大括号；
3).注意作用域问题，在方括号内部定义的变量，在外部是没法调用的


4、do while

do while循环的格式：

do{

循环体;

}while(条件);

语句含义：语句开始时，首先执行一次循环体，再进行判断while后面的条件是否成立，如果不成立，结束循环。


5、for循环

for循环格式：
for(表达式一;表达式二;表达式3){
循环体;
}

语句执行过程：
1).先求解表达式一，在求解表达式二，如果表达式二的值为真，则执行一次for的循环体；然后再执行表达式三，若为假，则结束循环；为真则执行下一步；

2).如果判断表达式三为真，则继续进入到表达式二的判断，若为假则推出循环，为真则继续执行循环体，直至循环结束。

for的嵌套（重难点）
一般情况下，for循环只有两层的嵌套，3层的嵌套比较少见。

两层嵌套：外层for循环控制的是行数；内层循环控制的是列数。
典型练习：
习题1.

习题2.

习题3.

习题4.打印9*9乘法表


上述图案均是由for循环嵌套打印出来，作为思索练习。