(1)分支结构

   分支结构指的是进行逻辑判断，当满足于某些条件的时候才会执行某些语句。

 分支结构有两类：if分支结构与switch分支结构。

 (2)循环结构

包括while循环和for循环

(3)对于不知道循环次数但知道循环条件的用while循环。

知道循环次数不知道循环条件用for循环。

(4)在进行循环处理的时候有两个关键字：continue，break；

continue:会跳过循环体的剩余部分，返回到循环的判断处；

示例：public class Test {






 public static void main(String[] args) {


 


 for(int i=1;i<=5;i++)


 {


 if(i==3)


 {


 continue;


 }


 System.out.println(i);


 }


 


 }





}

结果：

1

2

4

5





break：跳出循环

示例：

public class Test {






 public static void main(String[] args) {


 


 for(int i=1;i<=5;i++)


 {


 if(i==3)


 {


 continue;


 }


 System.out.println(i);


 }


 


 }





}

结果：

1

2









(4)循环嵌套

示例：

public class Test {






 public static void main(String[] args) {


 


 for(int x=1;x<=9;x++)


 {


 for(int y=1;y<=x;y++)


 {


 System.out.print(x+"*"+y+"="+x*y+"\t");


 }


 System.out.println();//换行


 }


 


 }





}

结果：

1*1=1
 

2*1=2
 2*2=4
 

3*1=3
 3*2=6
 3*3=9
 

4*1=4
 4*2=8
 4*3=12
 4*4=16
 

5*1=5
 5*2=10
 5*3=15
 5*4=20
 5*5=25
 

6*1=6
 6*2=12
 6*3=18
 6*4=24
 6*5=30
 6*6=36
 

7*1=7
 7*2=14
 7*3=21
 7*4=28
 7*5=35
 7*6=42
 7*7=49
 

8*1=8
 8*2=16
 8*3=24
 8*4=32
 8*5=40
 8*6=48
 8*7=56
 8*8=64
 

9*1=9
 9*2=18
 9*3=27
 9*4=36
 9*5=45
 9*6=54
 9*7=63
 9*8=72
 9*9=81
 





示例：打印三角形





public class Test {






 public static void main(String[] args) {


 


   int line=5;//打印5行


 


 for(int x=1;x<=line;x++)//x控制行数


 {//y控制列的空格数


 for(int y=1;y<=line-x;y++)


 {


 System.out.print(" ");


 }


 for(int y=1;y<=x;y++)//控制*的个数


 {


 System.out.print("* ");//换行


 }


 System.out.println();//换行


 }


 


 }





}

  结果

    * 

   * * 

  * * * 

 * * * * 

* * * * * 

Hello,everyone! forever之前给大家介绍了C语言的分支结构和循环结构，在分支中介绍了分支语句嵌套，但当时没有介绍 switch 嵌套，所以这次主要介绍 switch 嵌套和循环嵌套.
 首先来说说什么是嵌套吧！一个语句内包含另一个完整的语句结构称为语句嵌套。内嵌套的语句结构内还可以继续嵌套其他语句结构，这就构成多层嵌套。如：在循环体内嵌套一个完整的循环语句，就称为循环嵌套；在内部循环嵌套里在嵌套一个循环结构，就是多层循环。嵌套的含义是指“完整的包含”。
 
switch 嵌套
 
如同 if 语句一样，switch 语句也可以构成嵌套结构。在 switch-case 内部再嵌套一个 switch-case 语句，就构成 switch 嵌套结构；若内部的内部再继续嵌套就会构成多层嵌套。
 1、语法结构：
 以下是 switch 嵌套结构，default 可以看情况使用，不使用时就相当于不处理。一般用 default 时，在后面就可以不加 break。
 
switch (表达式1)
{
case 常量表达式1:语句1;
	switch (表达式2)
	{
	case 常量表达式A:语句a; 
		break;
	case 常量表达式B:语句b;
		break;
		……
	default:语句N;
	}
	break;
case 常量表达式2:语句2;
	switch (表达式n)
	{
		……
	}
	break;
case 常量表达式3:语句3;
	break;
	……
default:语句n;
}
 
2、switch-case 嵌套语句程序示例
 例题一：简单的理解 switch 语句嵌套结构
 
*简单的switch嵌套程序*
#include<stdio.h>
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);   //先输入两个值
	switch (a)    //这个外部 switch 对 a 进行判断
	{
	case 1:       //a=1时进入内部嵌套 switch 语句
		switch (b)   //这里 switch 对 b 进行判断
		{
		case 0:printf("$$$\n");
			break;
		case 1:printf("&&&\n");
		default:printf("***");   //这里是除了以上情况外的其他情况
			break;
		}
		break;   //结束 case1 内部的嵌套语句
	case 2:printf("###\n");
		break;
	case 3:printf("@@@\n");
	default:printf("!!!\n");
	}
	return 0;
}
 
运行结果：
 

 例题二：switch 和 if 的结合使用。请输入星期几的第一个字母来判断是星期几，如果第一个字母一样则继续判断第二个字母。
 
*请输入星期几的第一个字母来判断是星期几，如果第一个字母一样则继续判断第二个字母。*
#include<stdio.h>
#include<ctype.h>//这是toupper 函数调用头文件
int main()
{
	char letter1;
	char letter2;
	printf("请输入星期中某一天的第一个字母：（M/W/F/T/S）\n");
	scanf("%c", &letter1);
	letter1 = toupper(letter1);// toupper 是一个将小写字母转换成大写字母的函数
	getchar();//利用 getchar 消除回车符'\n',如果没有这个 getchar ,
	switch (letter1)     //那么后面继续输入第二个字母时就会输入回车符'\n',直接判断为 error
	{
	case 'M':printf("星期一\n");
		break;
	case 'W':printf("星期三\n");
		break;
	case 'F':printf("星期五\n");
		break;
	case 'T':printf("请输入第二个字母：(u/h)\n");
		scanf("%c", &letter2);
		if (letter2 == 'u')//case 内部结合 if-else 语句使用
		{
			printf("星期二\n");
		}
		else if (letter2 == 'h')
		{
			printf("星期四\n");
		}
		else
		{
			printf("error\n");
		}
		break;
	case 'S':printf("请输入第二个字母：(a/u)\n");
		scanf("%c", &letter2);
		if (letter2 == 'a')
		{
			printf("星期六\n");
		}
		else if (letter2 == 'u')
		{
			printf("星期天\n");
		}
		else
		{
			printf("error\n");
		}
		break;
	default:printf("error\n");
	}
	return 0;
}
 
运行结果：查找星期二
 
 
循环嵌套
 
循环结构的循环语句可以是任意合法的 C 语句。若一个循环结构的循环体中包含了另一循环语句，则构成了循环的嵌套，称为多重循环。嵌套的含义是指“完整的的包含”，那么循环的嵌套是指在一个循环的循环体内完整的包含另一个或另外几个循环结构。C 语言中三种循环控制语句可以相互嵌套在一起。
 1、while 循环嵌套
 （1）语法结构：
 
while (表达式1)
{
	语句1;
	while(表达式2)
	{
		语句2;
	}
	……
}
 
(2)while 循环嵌套程序示例
 示例一：利用 while 循环嵌套打印九九乘法表
 
//打印九九乘法表
#include<stdio.h>
int main()
{
	int i = 1, j = 1;
	while (i < 10)
	{
		j = 1;
		while (j <= i)
		{
			printf("%d*%d=%-4d ", j, i, i * j);//%-4d意思是左对齐并且保证留四个字符长度的距离
			j++;
		}
		printf("\n");//起到换列的作用
		i++;
	}
	return 0;
}
 
运行结果：九九乘法表打印
 
 
2、do-while 嵌套循环
 （1）语法结构
 
do
{
	语句1;
	do
	{
		语句2;
	} while ();//一定要注意do-while语句后面的“分号”，不能丢
	……
} while ();
 
（2）do-while 循环嵌套示例
 随机打印2-n+1个数字
 
#include<stdio.h>//随机打印 2-n+1 个数
int main()
{
	
	int i = 0;
	int n = 0;
	scanf("%d", &n);
	do
	{
		i++;
		do
		{
			i++;
			printf("%d\n", i);
		} while (i <= n);
	} while(i<=n);
	return 0;
}
 
运行结果：
 
 
3、for 循环嵌套
 （1）语法结构
 
for ( ; ; )
{
	语句1;
	for( ; ; )
	{
		语句2;
	}
	……
}
 
（2）for 循环嵌套示例
 示例一：数字金字塔
 
//利用 for 循环嵌套实现数字金字塔
#include<stdio.h>//数字金字塔
int main()
{
	int i = 0, j = 0;
	int n = 0;
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		for (j = n-i; j >0; j--)//此循环语句为了实现空格打印
		{
			printf(" ");
		}
		for (j = 1; j <= i; j++)
		{
			printf("%d ", i);
		}
		printf("\n");//实现换行

	}
	return 0;
}
 
运行结果：输入5，进行金字塔排列
 
 
示例二：冒泡排序法
 for 循环实现从小到大冒泡排序
 
//利用 for 循环嵌套实现从小到大冒泡排序
#include<stdio.h>//冒泡排序
int main()
{
	int n = 0;
	int i = 0, j = 0;
	int arr[100] = { 0 };
	int temp = 0;
	scanf("%d", &n);
	for (i = 0; i < n; i++)//利用循环给数组赋值
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < n - 1; i++)//冒泡排序外层循环进行 n-1 轮排序![请添加图片描述](https://img-blog.csdnimg.cn/9caa20aa99b742fc99e480f65f3c12ac.png)

	{
		for (j = 0; j < n - i - 1; j++)//冒泡排序内层循环每轮要进行 n-i-1 层比较
		{
			if (arr[j] > arr[j + 1])//进行大小比较
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
 
运行结果：随机输入5个数进行排序
 
 
示例三：打印 100-200 之间的素数
 for 循环嵌套打印100-200间素数
 
//打印100-200间素数
#include<stdio.h>//打印100-200间素数
int main()
{
	
	int j = 0;
	for (int i = 100; i <= 200; i++)
	{
		for (j = 2; j < i; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}
		if (i == j)
		{
			printf("%d\n", i);
		}
	}
	return 0;
}
 
运行结果：
 
 
总结
 
1、在循环以及循环嵌套中依然会常用到 break 和 continue ，之前文章详细介绍过这两个语句，因此要注意他们的使用；
 2、再多层嵌套里一般也会用到 goto 跳转语句，终止程序在某些结构中的深度嵌套；
 3、除以上基本嵌套之外，while、do-while、for以及和其他分支语句都可以任意嵌套组合使用，而且 C 语言中不限制嵌套的层数，我们可以合理组织程序的模块结构；
 4、在编写程序时，尽量避免过多的嵌套，影响代码整体美观，嵌套过多也对硬件相关配置要求更高。
 目前就这些！这些代码都比较简单，浅显易懂，希望对一些初学者有一定帮助，也望其他大佬能多多指点！如有不足或错误之处，请谅解并指教哈！
 谢谢观看，再见啦！
 以上代码均可运行，所用编译环境为 vs2019 ,运行时注意加上编译头文件#define _CRT_SECURE_NO_WARNINGS 1

程序基本结构、简单分支、异常处理、三大实例分析、基本循环结构、通用循环构造方法、死循环\嵌套循环、布尔表达式
1、程序基本结构

Python不支持直到型循环结构（可以通过特殊的方法，构造直到型循环结构）



简单条件构造：
简单条件基本形式：　＜ｅｘｐｒ＞＜ｒｅｌｏｐ＞＜ｅｘｐｒ＞
＜ｒｅｌｏｐ＞是关系操作符＜，＜＝，＝＝，＞，！＝
使用“＝”表示赋值语句，使用“＝＝”表示等于
除数字外，字符或字符串也可以按照字典顺序用于条件比较
＜ｃｏｎｄｉｔｉｏｎ＞是布尔表达式，为ｂｏｏｌ类型，布尔值的真和假以字符串Ｔｒｕｅ和Ｆａｌｓｅ表示
下面是求解二次方程的源程序

改进后版本，加入了判断语句

改进版



》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》。未写完，明晚继续。多分支的决策方法
2017、9、29 继续学习 多分支
多分支决策
要解决双根问题，就需要对delta等于0的情况进行处理。语句的结构上要引入嵌套结构。
当delta<0,处理无实根情况，
当delta=0，处理实根情况
当delta>=0,处理双根情况。
一种解决方案是在程序中使用两个if——else语句。
把一个复合语句放到另一个语句中的结构之中成为嵌套。
下面是使用嵌套实现三分支结构决策的代码片段
if delta<0:print(Equation has no real roots)else:if delta ==0 :
x=-b/(2*a)print("There is a double root at",x)else:#计算两个实根
此嵌套方案的流程图：

多分支决策：
多分支决策是解决复杂问题的重要手段之一。
一个三分支决策可以由两个二分支结构嵌套实现。
使用if-else描述多分支决策时，实现更多分支需要更多嵌套，影响程序的易读性。
》》》》Python使用if-elif-else描述多分支决策，简化分支结构的嵌套问题。
语句格式如下：
if :
elif :
elif:...else:
三分支程序:

改进后的程序流程图：

前面提及的空气质量提醒程序：（多分支）

《《《《《《《《《《《《《《《《《《《《《《《《《《《《异常处理》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
如果处理特殊情况的分支语句塞满整个代码空间，处理正常工作的主程序就显得不那么清晰易读了。因此引入异常处理机制，来解决这类问题。
异常处理机制使得程序设计语言可以编写代码来捕获和处理在程序运行发生的错误，而不是显示检查代码的每一步是否成功。
异常处理可以简单的理解为： 请做这些步骤，如果发生异常，按这样处理。
异常处理语句：
Python使用try...except...，可使程序不因运行错误而崩溃。
try:

except　　:

except　　:

except:

异常处理小例子：

异常处理语句：
Python的异常处理语句还可以使用else和finally关键字。
try:

except　　:

except　　:

except:

else:

finally:

下面是利用try except的异常处理实例：

异常处理语句的优点：
try...except可以捕捉任何类型的错误。并提供一个稳定的出口
在二次方程求解中，还会有其他可能的错误，如：输入非数值类型（NameError），输入无效的表达式（SyntaxError）等。此时一个try语句可以匹配多个except来实现。
继续改进二次函数求根的函数，使之可以应对各种类型的错误。

 
分支结构switch、循环结构：for、嵌套循环for、break、continue
 
一、分支结构switch
二、循环结构1：for
三、Day04 -- 循环+数组
四、拓展
  
 

 
一、分支结构switch
 
 
 
  1、概述
  
 

  也像if一样，可以完成先判断的需求
 
 
 

  也支持 byte short int char String 数据类型
 
 
 
  2、语法
  
 

  如下
 
 
 
switch(判断条件){
    case 0 : sysout(0);
    break;
    case 1 : sysout(1);
    break;
    case 2 : sysout(2);
    break;
    //以上case都不满足才来这
    default : sysout(defalt);
    break;
}
 
二、循环结构1：for
 
 
 
  1、概述
  
 

  循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
 
 
 

  它由循环体中的条件，判断继续执行某个功能还是退出循环。
 
 
 

  根据判断条件，循环结构又细分为先判断后执行的循环结构和先执行后判断的循环结构。
 
 
 
  2、形式
  
 

  如下
 
 
 
for(开始条件；循环条件；更改条件){
    循环体代码......
}
 

 第一次执行，i = 0 —> 判断是否小于10 —> 输出 0 —> 0++为 1；
 第二次执行，i 为1 后判断是否小于10 —> 输出 1 —> 1 自增为 2； …
 第11次执行，i 为10 后判断是否小于等于10 —> 输出10 —>自增为11；
 第12 次执行，i为11后判断是否小于等于10 ---->判断不成立，结束。### 三、Day04 – 循环+数组
 
三、Day04 – 循环+数组
 
 
 
  1、嵌套for循环
  
 

  概述：
  
 根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，在继续执行判断
 
 
 

  特点1：外循环执行1次，内循环执行多次
 
 
 

  特点2：外循环控制行，内循环控制列
 
 
 

  形式：
 
 
 
for(...){
    for(...){
    
    }
}
 
 
 
  2、break和continue
  
 

  用来终止循环，可以用两种方式
 
 
 
形式：
 
break：中断当前循环，简单粗暴
 
for() {
           代码1
           if(条件) {
                代码3..
                break; //如果成立，直接跳出这个for循环
           }
           代码2..
     }
 
continue：跳出本次循环，进入下一轮
 
for() {
           代码1
           if(条件) {
                代码3..
                continue; //如果成立，直接跳出这个for循环，进入下一行
           }
           代码2..
     }
 
四、拓展
 
1、&和&&的区别
 当一个&表达式在求值的时候，两个操作都会被求值，&&更像是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会被第二个操作数。如果第一个操作数取值为fale，第二个操作数就不会被求值
 
2、a=a+4和a+=4的区别
 
 3、求【0,100】中，奇数的个数
 
//统计奇偶数个数
	public static void t4() {
		//先输出所求区间所有的数
		//定义一个变量存储奇偶数个数
		int count = 0;
		int count1 = 0;
		for(int i = 1; i<=100;i++) {
			//找到其中的奇数
			if(i % 2 == 1) {
				count++;
			}
			if(i % 2 == 0) {
				count1++;
			}
		}
		System.out.println("奇数个数为："+count);
		System.out.println("偶数个数为："+count1);
	}在这里插入代码片
 
4、求【0,100】中，偶数的和
 
//统计偶数的和
	public static void t5() {
		int count = 0;
		//循环获取每个数
		for (int i = 1; i <= 100; i++) {
			//找到偶数
			if(i % 2 == 0) {
				//定义一个变量存储偶数
				count = count + i;
			}
		}
		System.out.println(count);
	}
 
5、统计1+1/2+1/3+1/4+…+1/10的和
 
//统计1+1/2+1/3+1/4+....+1/10的和
	public static void t6() {
		//定义一个变量存储和
		//分子为常量
		double sum = 0;
		//循环获取分母
			for(int j = 1; j <= 10; j++) {
				sum = sum + (1.0 / j);
			}
			System.out.println(sum);
	}
 
6、打印右直角三角形（空格倒三角+右直角）
 
public static void t7() {
		for(int i = 1; i <= 9; i++) {
			//先打印一个空白的左倒三角
			for(int j = 9; j >= i; j--) {
				System.out.print("  ");
			}
			//再打印一个右直角
			for(int j = 1; j <= i; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}