循环结构


while循环


do…while循环


for循环


在Java5中引入了一种主要用于数组的增强型for循环


while循环

while是最基本的循环, 它的结构为:

while(布尔表达式){
	// 循环内容
}


只要布尔表达式为true, 循环就会一直执行下去
我们大多数情况是会让循环停下来的, 我们需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行, 比如服务器的请求响应监听等
循环条件一直为true就会造成无限循环[死循环], 我们正常业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃!

代码
// 死循环
while(true){
	// 等待客户端连接
	// 定时检查
	// ....
}

do…while循环

对于while语言而言, 如果不满足条件, 则不能进入循环。但有时候我们需要即使不满足条件, 但也至少执行一次。
do…while循环和while循环相似, 不同的是, do…while循环至少会执行一次

do{
	// 代码语句
}while(布尔表达式);


while和do-while的区别:

- while先判断后执行。do-while是先执行后判断!

- do…while总是保证循环体会被至少执行一次!这是他们的主要差别。

For循环

虽然所有循环结构都可以用 while 或者 do…while表示, 但 Java 提供了另一种语句 — for 循环, 使一些循环结构变得更加简单
for 循环语句是支持迭代的一种通用结构, 是最有效的, 最灵活的循环结构
for 循环执行的次数是在执行前就确定的
语法:

/**
 * 关于 for 循环有一下几点说明:
 * 
 * 最先执行初始化步骤, 可以声明一种类型, 但可初始化一个或多个循环控制变量, 也可以是空语句
 * 然后, 检测布尔表达式的值。如果为true, 循环体被执行。如果为false, 循环终止, 开始执行循环体后面的语句
 * 执行一次循环后, 更新循环控制变量(迭代因子控制循环变量的增减)
 * 再次检测布尔表达式, 循环上面的过程
 */
for(初始化; 布尔表达式; 更新) {
	// 代码语句
}

// 练习: 用while或for循环输出1-1000之间能被5整除的数, 并且每行输出3个
for (int i = 0; i <= 1000; i++) {
	if (i%5==0) {
		System.out.println(i+"\t");
	}
	if (i%(5*3)==0) { // 每行
		System.out.println();
		// System.out.print("\n");
	}
	// println 输出完, 会换行
	// print 输出完, 不会换行
}

增强for循环

这里我们先只是见一面, 做个了解, 之后数组我们重点使用
Java5引入了一种主要用于数组或集合的增强型for循环
Java增强for循环语法格式如下:

for(声明语句 : 表达式){
	// 代码句子
}


声明语句: 声明新的局部变量, 该变量的类型必须和数组元素的类型匹配。起作用域限定在循环语句块, 其值与此时数组元素的值相等
表达式: 表达式是要访问的数组名, 或者是返回值为数组的方法

代码(两种写法, 结果一样)
int[] numbers = {10, 20, 30, 40, 50};  // 定义了一个数组

for(int i = 0; i < number.length;i++){
	System.out.println(numbers[i]);
}
System.out.println("=====================");
// 遍历数组的元素
for(int x : numbers){
	System.out.println(x);
}

break, continue, 关键字goto

break在任何循环语句的主体部分, 均可用break控制循环的流程。break用于强行退出循环, 不执行循环中剩余的语句。(break语句也可在switch语句中使用)
continue语句用在循环语句体中, 用于终止某次循环过程, 即跳过循环体中尚未执行的语句, 接着进行下一次是否执行循环的判定。
关于goto关键字

goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字, 但并未在语言中得到正式的使用; Java没有goto。然而, 在break和continue这两个关键字的身上, 我们仍然能看出一些goto的影子—带标签的break和continue。
"标签"实质后面跟一个冒号的标识符, 例如: label
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是: 我们希望在其中嵌套另一个循环, 由于break和continue关键字通常只终端当前循环, 但若随标签使用, 他们就会中断到存在标签的地方。



outer:for (int i = 101; i < 150; i++) {
            for (int j = 2; j<i/2;j++) {
                if (i%j==0) {
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }

练习
// 打印三角形  5行
        for (int i = 1; i < 6; i++) {
            for (int j = 5; j >= i ; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i ; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

所谓循环，就是重复执行一段代码，计算机的判断能力和人相比差的很远，计算机更擅长一件事情——不停的重复。而我们在JavaScript中把这叫做循环。下面让我们来了解了解JavaScript里的循环。
js循环结构有哪些
js循环结构有三种

for循环 ==> 用来多次遍历代码块
while循环 ==> 当指定条件为true时，循环代码块
do while ==> 当指定条件伪true时，循环代码块

1、for循环
for是由两个部分组成，条件控制和循环体

语法：
for(初始化表达式;循环条件表达式;循环后的操作表达式){
	需要重复的代码块;
}

for语句结构如图：



for循环的执行顺序
1.初始化表达式

2. 循环条件表达式

3. 需要重复的代码块

4. 循环后的操作表达式
简单的for循环，循环执行一次会改变一个变量的值

举例：输出1到100的值
for(var i=1; i <= 100; i++){
//在循环开始时设置一个变量i；//定义运行循环的条件i<=100;//每个循环执行后，变量增加1
console.log(i);
}

2、while循环
while循环会重复执行一段代码，直到某个条件不再满足。

语法：
while(条件表达式语句){
	执行的代码块;
}

while循环结构如图：



while执行顺序

当我们的使用条件条件返回值是true，就会执行大括号里面的代码块，执行完大括号的语句之后，会重复大括号里的语句，直到判定条件返回值为false，才会结束循环。
案例：
var i = 0;
while (i < 10){
	console.log(i);
	i++;
}
//while循环会先判定条件，再根据条件是否成立达成决定是否进入循环
//如果条件一开始就是false ，则不会进入循环

缺点：

使用while语句的时候，一定要写大括号
如果没有条件的话，会无限的运行下去，造成死循环。

3、do while循环的结构
do while 结构的基本原理和while结构是基本相同的，但是它保证循环体至少被执行一次。因为它是先执行代码，后判断条件

语法：
do {
	执行语句块;
}
while(条件表达式语句);

do while 执行顺序：

先执行一次code，再做判断。与while循环不同，do while无论条件如何 都会执行一次代码

案例：
var i = 0;
do{
	console.log(i);
	i++;
}while(i<10);

while 和 do while的不同

while:   先判断 再执行   条件不成立   循环体 一遍都不执行
do…while: 先执行 再判断  条件不成立  循环体 至少执行一遍

1.6 Python循环结构
1.6 Python循环结构
1.6.1 while型循环
1.6.2 for ... in 循环
1.6.3 range()函数:
1.6.4 break和continue语句及循环中的else子句：

1.6 Python循环结构


循环结构就是为了将相似或者相同的代码操作变得更见简洁，使得代码可以重复利用


循环结构分为2类：while循环 和 for…in循环


1.6.1 while型循环
格式1：
    while 条件表达式：
        循环的内容
        [变量的变化]

格式2：

    while 条件表达式：
        循环的内容
        [变量的变化]
    else:
        python语句..


注意:while循环中的else是在while条件表达式为假的情况下执行的代码内容,一般用于判断起始条件是否为假等相关操作。

实例使用了 while 来计算 1 到 100 的总和：
#!/usr/bin/env python3

n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n,sum))


执行结果如下：

1 到 100 之和为: 5050

死循环：

死循环就是循环不会终止的循环类型，通过将用于判断的条件表达式设置为永远为True来实现。

    while True:
        python代码...
        python代码...
        ...

#!/usr/bin/python3

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)

print ("Good bye!")


你可以使用 CTRL+C 来退出当前的无限循环
执行以上脚本，输出结果如下：


输入一个数字  :5

你输入的数字是:  5

输入一个数字  :

1.6.2 for … in 循环

for…in 循环用于遍历容器类的数据（字符串，列表，元组，字典，集合）

格式：

    for  变量  in  容器：
        python代码,可以在此使用变量

格式2：

    for 变量1,变量2 in 容器：
        python代码,可以在此使用变量1和变量2


要求遍历的容器必须是一下几种格式：

[(),(),()] 列表中有元组
[[],[],[]] 列表中有列表
((),(),()) 元组中有元组
{(),(),()} 集合中有元组
字典的特殊使用



格式3：
    for  变量  in  容器：
        python代码,可以在此使用变量
    else:
        循环结束是执行的代码！

>>>languages = ["C", "C++", "Perl", "Python"] 
>>> for x in languages:
...     print (x)
... 
C
C++
Perl
Python
>>>

1.6.3 range()函数:

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

>>>for i in range(5,9) :
    print(i)


5
6
7
8
>>>

>>>for i in range(0, 10, 3) :
    print(i)


0
3
6
9
>>>

>>>for i in range(-10, -100, -30) :
    print(i)

-10
-40
-70
>>>


您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

输出乘法口诀：
for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+'*'+str(j)+"="+str(i*j),end="")
    print()

1.3.7 作业：逆向输出乘法口诀：
for i in range(9,0,-1):
    for j in range(i,0,-1):
        print(str(i)+'*'+str(j)+"="+str(i*j),end="")
    print()

1.6.4 break和continue语句及循环中的else子句：
break语句：

break作用:在循环中break的作用是终止当前循环结构的后续操作，一旦程序运行了break，循环也就终止了！
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'b':
      break
   print ('当前字母为 :', letter)

var = 10                    # 第二个实例
while var > 0:              
   print ('当期变量值为 :', var)
   var = var -1
   if var == 5:
      break

print ("Good bye!")


执行以上脚本输出结果为：


当前字母为 : R

当前字母为 : u

当前字母为 : n

当前字母为 : o

当前字母为 : o

当期变量值为 : 10

当期变量值为 : 9

当期变量值为 : 8

当期变量值为 : 7

当期变量值为 : 6

Good bye!

continue语句：

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)

var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")


执行以上脚本输出结果为：


当前字母 : R

当前字母 : u

当前字母 : n

当前字母 : b

当前变量值 : 9

当前变量值 : 8

当前变量值 : 7

当前变量值 : 6

当前变量值 : 4

当前变量值 : 3

当前变量值 : 2

当前变量值 : 1

当前变量值 : 0

Good bye!


循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
如下实例用于查询质数的循环例子:

#!/usr/bin/python3

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')


执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass 语句:


Python pass是空语句，是为了保持程序结构的完整性。


pass 不做任何事情，一般用做占位语句，如下实例


>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)
最小的类:


>>>class MyEmptyClass:
...     pass

循环结构

一，知识点

　　　1 for循环：

　　　　for (循环控制变量初始化; 循环终止条件; 循环控制变量增量)

　　　　{

　　　　　　循环体

　　　　}

　　　　循环执行步骤：第一，先进行循环控制变量初始化；

　　　　　　　　　　　第二，执行循环终止条件，如果判断结果为真，则进入第三步；如果为假则循环终止并退出；

　　　　　　　　　　　第三，执行循环体；

　　　　　　　　　　　第四，执行循环控制变量增量，转入第二步；

　　　　注：for循环()中的三部分除了循环终止条件外，其他两部分都可以省略，但标准的for循环中，应该把循环控制变量的初始化，增量都放在()当中，并且在循环体中绝对不应该更改循环控制变量；

　　2.while：

　　　　循环控制变量初始化

　　　　while(循环终止条件)

　　　　{

　　　　　　循环体

　　　　　　循环控制变量增量

　　　　}

　　　　循环执行步骤：第一，先进行循环控制变量初始化(在while之前)；

　　　　　　　　　　　第二，判断循环终止条件，如果判断结果为真，则进入第三步；如果为假则不执行循环体；

　　　　　　　　　　　第三，执行循环体；

　　　　　　　　　　 第四，执行循环控制变量增量，转入第二步；

　 3 do while：

　　　　循环控制变量初始化

　　　　do

　　　　{

　　　　　　循环体

　　　　　　循环控制变量增量

　　　　}while (循环终止条件);

　　　　循环执行步骤：第一，先进行循环控制变量初始化(在do while之前)；

　　　　　　　　　　　第二，执行循环体；

　　　　　　　　　　　第三，执行循环控制变量增量；

　　　　　　　　　　　第四，判断循环终止条件，如果判断结果为真，则返回第二步；如果为假则直接退出循环；

　　　4 总结：不管哪种循环结构，都不能缺少循环控制条件初始化，终止条件，循环控制变量增量，循环体这四部分；while循环是先判断后执行，do while循环是先执行后判断，等循环一次之后，其实都是一样的；

　　　二，如何使用

　　　1，for循环

　　　例：杨老师6班测试

　　　【题目描述】

输入n，输出一个n*n的正方形，正方形由符号c1和c2组成，正方形的四条边和对角线由c1组成，其余部分由c2组成。
#include<stdio.h>
int main()
{
    int n,m,i,j,k;
    char b,c;
    scanf("%d %c %c",&n,&b,&c);
    m=n+1;
    for(i=1; i<=n; i++)
    {
        if(i==1||i==n)
        {
            for(j=1; j<=n; j++)
            {
                printf("%c",b);
            }
            printf("\n");
        }
           else if(i!=1&&i!=n)
            {
                for(k=1; k<=n; k++)
                {
                    if(k==1||k==n||k==i||i+k==m)
                    {
                        printf("%c",b);
                    }
                    else
                        printf("%c",c);
                }
                printf("\n");
            }
        }
        return 0;
    }    

利用for循环来控制行和列的输出；进而达到题目要求；

2，while循环

例，最短距离的点。

描述

给出一些整数对，它们表示一些平面上的坐标点，给定一个点，求所有那些点到该点最短距离的点。结构为：第一个整数对为所给定的点，后面的整数对为所有其他的点。
#include<stdio.h>
#include<math.h>
int main()
{
    int a,b,c,d,x,y,n=0,e,max=99999999;
    scanf("%d %d",&a,&b);
    while(~scanf("%d %d",&c,&d))
    {
        e=sqrt((a-c)*(a-c)+(b-d)*(b-d));
        if(max>e)
        {
            max=e;
            x=c;
            y=d;
        }
    }
    printf("%d %d",x,y);
    return 0;
}

这道题没给出输入几组数据，就可以用while循环来解决，对于此类问题不知道循环结束的条件，就可以用while循环语句，在通过break结束，或者continue来继续执行；

3，do while 循环

例
#include <stdio.h>
main()
{
int i,sum=0;
scanf("%d",&i);
do
{ 
sum+=i;
i++;
}while(i<=10);
printf("%d",sum);
}

输入：11

运行结果：11

虽然不满足循环条件，还是可以执行一次。

三，感悟

1，尽量使循环控制变量的取值采用半开半闭区间写法从功能上看，虽然半开半闭区间写法和闭区间写法的功能是完全相同的，但相比之下，半开半闭区间写法更能够直观地表达意思，具有更高的可读性。

2，尽量使循环体内工作量达到最小化，for 循环随着循环次数的增加，会加大对系统资源的消耗。如果你写的一个循环体内的代码相当耗费资源，或者代码行数众多（一般来说循环体内的代码不要超过 20 行），甚至超过一显示屏，那么这样的程序不仅可读性不高，而且还会让你的程序的运行效率大大降低。

3，避免在循环体内修改循环变量，在 for 循环语句中，我们应该严格避免在循环体内修改循环变量，否则很有可能导致循环失去控制，从而使程序执行违背我们的原意

4，尽量使逻辑判断语句置于循环语句外层，一般情况下，我们应该尽量避免在程序的循环体内包含逻辑判断语句。当循环体内不得已而存在逻辑判断语句，并且循环次数很大时，我们应该尽量想办法将逻辑判断语句移到循环语句的外层，从而使程序减少执行逻辑判断语句的次数，提高程序的执行效率。

5，尽量将循环嵌套控制在 3 层以内，如果超过三个循环，这样程序的执行效率也会很低。因此，如果代码循环嵌套超过 3 层，建议重新设计循环。