精华内容
下载资源
问答
  • 循环结构中嵌套分支
    2021-12-17 18:38:34

    1 分支结构

            

        <script>
            /* 
            1 程序
            程序 = 数据 + 算法
            数据:
                1 变量 存储一条数据 重新赋值会替换前面的值
                2 数组
                3 对象
            算法:
                1 顺序结构 从上往下 从左往右
                2 分支结构 根据不同的条件 做出不同的判断
                3 循环结构 重复的执行相同的代码
    
            2 分支结构
                1 单分支结构
                if(条件) {满足条件时执行的语句}
                一件事情满足就执行 不满足什么也不不做
                2 双分支结构
                if(条件) {满足条件时执行的语句}else{不满足条件时执行的语句}
                一件事情满足就执行if里的语句 不满足就执行else里的语句
                3 多分支结构
                if(条件){
                    满足当前条件执行的语句
                }else if(条件){
                    满足当前条件执行的语句
                }else if(条件){
                    满足当前条件执行的语句
                }else{
                    以上条件都不满足执行的语句
                }
                    注意 else可以省略
                        多选1执行,条件一旦满足,就不往下执行
            */
        </script>
        <script>
            var time = 21;
            if(time < 20) {
                console.log("good");
            };
            console.log("hahaha")
    
            var score = 100;
            if(score >= 60) {
                console.log('及格');
            }
        </script>
        <script>
            var time = 1;
            if(time < 20) {
                console.log('good')
            }else{
                console.log('evening')
            }
        </script>

     

     2 动态输入框

        <script>
            /* 
            1 动态输入框  
                1 语法
                prompt('提示',默认值)
                2 注意
                 默认值可以省略
                 返回string类型
    
            2 string类型转换成number类型 (强制转换)
            parseInt()  转换为整数 不会四舍五入
            parseFloat()  转换为小数 只能识别一个小数点 89.88.889  89.88
    
            3 string类型转换为number类型 (隐式转换)
            - * / % 
            num - 0 
            num * 1
            */
           var num = "99.89";
           var res = parseInt(num);
           console.log(res)
        </script>
        <script>
             var year = prompt('输入年份');
            if(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
                console.log("润")
            }else {
                console.log("不润")
            };
        </script>

     

    3 if相互嵌套

        <script>
            /* 
            分支结构可以相互嵌套
            */
            var sex = prompt("性别","男");
            var age = prompt("age");
            if(sex == "男") {
                if(age >= 22) {
                    console.log("可以男")
                }else{console.log("不能男")}
            }else if(sex == "女") {
                if(age >= 20) {
                    console.log("可以女")
                }else {
                    console.log("女不能")
                }
            }else {
                console.log("不难不女")
            }
    
            /* var sex = prompt("性别", "男");
            var age = prompt("age");
            if (sex == "男" && age >= 22) {
                console.log("可以男")
            } else if(sex == "女" && age >= 20){
                console.log("可以女")
            }else {
                console.log("不能")
            } */
            
           /*  var sex = prompt("性别", "男");
            var age = prompt("age");
            if(sex == "男" && age >= 20 || sex == "女" && age >= 20) {
                console.log("能结婚")
            }else {
                console.log("不能结婚")
            } */
        </script>

    4  for循环

        <script>
            /* 
            1 语法
            for(循环变量;循环条件;执行规律) {
                循环语句
            }
    
            2 执行过程
                1 判断循环变量是否满足循环条件,不满足,直接退出循环
                2 满足,进入循环执行循环语句
                3 执行循环规律,判断循环变量是否满足循环条件,不满足,直接退出循环
                4 满足,进入循环执行循环语句
    
    
                for(语句1;语句2;语句3){
                    语句4;
                }
                1——2——4——3——2——4——3——2——4
                初始化循环变量只执行一次
                循环条件 条件满足一直循环 条件不满足直接退出循环
                循环规律 改变了变量的值 变量改变以后需要再判断是否满足条件
            */
        </script>
        <script>
            //控制台输出5遍你好
            /* for( var i=0;i<5;i++) {
                console.log("你好")
            } */
    
            //控制台输出1-100
            /* for(var i = 1;i <= 100;i++) {
                console.log(i)
            } */
    
            //控制台输出1-100的和
            // var num = 0;
           /*  for(var n = 1,sum = 0;n <= 100;n++) {
                num += n;
            }
            console.log(num); */
            
            //求一到五的阶乘
            for(var i = 1,ji = 1;i <= 20;i++) {
                ji*=i;
                console.log(ji)
            }
        </script>

    5 循环结构和分支结构相互嵌套 

    <script>
             //控制台输出1-100的和
            // var num = 0;
           /*  for(var n = 1,sum = 0;n <= 100;n++) {
                num += n;
            }
            console.log(num); */
    
            //求1-100之间偶数的和
            /* for(var i = 1,sum = 0;i <= 100;i++) {
                if(i % 2 === 0) {
                    sum += i;
                    
                }
            }
            console.log(sum) */
    
            /* for(var i = 2,sum = 0;i <= 100;i += 2) {
                sum += i;
            }
            console.log(sum) */
    
            //求1-100之间奇数的和
            /* for(var i = 1,sum = 0;i <= 100;i += 2){
                sum += i;
            }
            console.log(sum) */
            /* for(var i = 1,sum = 0;i <= 100;i++) {
                if(i % 2 === 1) {
                    sum += i;
                }
            }
            console.log(sum) */
    
            //计算1-100之间所有不能被7整除的整数之和
            for(var i = 1,sum = 0;i <= 100;i++) {
                if(i % 7 !== 0) {
                    sum += i;
                }
            }
            console.log(sum);
        </script>

    6 循环嵌套

        <script>
            /* 
            1 语法
                for(循环变量;循环条件;循环规律) {
                    for(循环变量;循环条件;循环规律) {
                        循环语句;
                    }
                }
            2 原理
                外层循环走一下,内层循环走一圈
                外层循环遍历行,内层循环遍历列
            */
        </script>

     //九九乘法表

    // 倒三角

    //等腰三角

    //计算器

    //水仙花数 三位

    //四位数各位乘积

        <script>
            /* 
    
            * * * * * 
            * * * * * 
            * * * * * 
            * * * * * 
            * * * * * 
            
            
            */
           //外层循环遍历行 控制执行的次数
            /* for(var row = 1;row <= 5;row++) {
                //内层循环遍历列 控制实际的输出
                for(var col = 1;col <= 5;col++) {
                    document.write(" * ")
                }
                document.write("<br />")
            } */
            /* 
    
            *
            * *
            * * *
            * * * *
            * * * * * 
            
            */
            /* for(var row = 1;row <= 5;row++) {
                //内层循环遍历列 控制实际的输出
                for(var col = 1;col <= row;col++) {  
                    document.write(" * ")
                }
                document.write("<br />")
            } */
            //九九乘法表
            /* for(var i = 1;i <= 9;i++) {
                for(var j = 1;j <= i;j++) {
                    //结果小于十,加一个空格  第一列不需要加空格
                    var res = i*j;
                    if(res < 10 && j > 1) {
                       res = res + "&nbsp&nbsp" ;
                    }
                    document.write(j + "x" + i + "=" + res +"&nbsp")
                }
                document.write("<br />")
            } */
            // 倒三角
            /* for(var row = 1;row <= 5;row++) {
                //内层循环遍历列 控制实际的输出
                for(var col = 5;col >= row;col--) {
                    document.write(" * ")
                }
                document.write("<br />")
            } */
            /* for(var row = 1;row <= 5;row++) {
                for(var col = 1;col <= 6 - row;col++) {
                    document.write(" * ")
                }
                document.write("<br />")
            } */
            //等腰三角
            for(var row = 1;row <= 5;row++) {
                //内层循环遍历列 控制实际的输出
                for(var k = 1;k <= 6 - row;k++) {
                    document.write("&nbsp")
                }
    
                for(var col = 1;col <= row;col++) {
                    document.write(" * ")
                }
                document.write("<br />")
            }
            //计算器
            /* var num1 = parseFloat(prompt("数字"));
            var num2 = parseFloat(prompt("数字"));
            var symbol = prompt("+-/*");
            if(symbol == '+') {
                console.log(num1 + num2);
            }else if(symbol == '-') {
                console.log(num1 - num2);
            }else if(symbol == '*') {
                console.log(num1 * num2);
            }else if(symbol == '/') {
                if(num2 != 0) {
                    console.log(num1 / num2);
                }else {
                    console.log("0错误")
                }
            }else {
                console.log("error")
            } */
            //
            /* var num1 = parseFloat(prompt("数字"));
            var num2 = parseFloat(prompt("数字"));
            var num3 = parseFloat(prompt("数字"));
            if(num1 != num2 && num1 != num3 && num2 != num3) {
                console.log("0");
            }else if(num1 == num2 && num1 != num3 || num2 == num3 && num2 != num1) {
                console.log("1");
            }else {
                console.log("2");
            } */
            //水仙花数 三位
            
            /* for(var i = 100;i <= 999;i++){
                var g = i%10;
                var s = parseInt(i/10)%10;
                var b = parseInt(i/100);
                if(g*g*g + s*s*s + b*b*b == i) {
                    console.log(i);
                }
            } */
            //四位数各位乘积
            /* var i = parseInt(prompt("四位数"));
            if(i > 999 && i <10000) {
                var g = i%10
                var s = parseInt(i%100)%10;
                var b = parseInt(i/100)%10;
                var q = parseInt(i/1000);
                console.log(g*s*b*q);
            }else {
                console.log("error")
            } */
        </script>

     

     7 break和continue

        <script>
            /* 
            break 退出整个循环
            continue 退出本次循环,继续下一轮循环
            break和continue后面的代码都不执行
            */
        </script>
        <script>
            /* for(var i = 1;i <= 10;i++) {
                if(i == 3) {
                    // break;
                    continue;
                }
                console.log(i)
            } */
            /* for(var i = 1,sum = 0;i <= 100;i++) {
                if(i % 3 != 0) {
                    sum+=i;
                    if(sum >= 2000){
                        console.log(sum,i)
                        break;
                    }
                }
            } */
            for(var i = 1,sum = 0;i <= 100;i++) {
                if(i % 7 == 0) {
                    continue;
                    }
                    sum+=i; 
                }
                console.log(sum)
        </script>

     

     8 for循环注意事项

        <script>
            /* 
            1 for循环语法
                for(循环变量;循环条件;执行规律) {
                    循环体;
                }
    
            2 循环变量
                循环变量;
                for(;循环条件;执行规律) {
                    循环体;
                }
                var i = 1;
                for(;i <=10;i++) {
                    console.log(i);
                
            3 循环条件 ---死循环
                for(var i = 1;;i++) {
                    i <= 100;  //不生效
                    console.log(i);
                }
    
            4 循环规律
                1
                    for(var i = 1;i <=100;) {
                console.log(i)
                i++;    
            }
                2
                    for(var i = 1;i <=100;) {
                console.log(i)
            }
    
            5 死循环
                for(;;) {
                console.log("1")
            }
            */
        </script>
    更多相关内容
  • 本文介绍了Java的分支结构、循环结构和循环嵌套,以及非常精细的讲解了初学者经常遇到的循环嵌套难题——九九乘法表,还列出了使用各个结构可能出现的问题,非常适合复习以及巩固理解所用

    Java分支结构(if、if else、switch)、循环结构(while、do while、for)


    前言

    本节我们来介绍下Java中的循环结构和分支结构


    一、分支结构

      分支结构有if、if else、switch,下面就来具体的说一说这些结构的用法以及需要注意的问题

    1.if条件语句

    格式:if(条件表达式){执行语句;}
    

    我们以一个例子来简单说明if语句的用法,完成程序如下:如果张三玩的石头人没有空大,那么队友就会跟他说666,代码如下:

    //如果石头人没有空大则i为1,默认为-1
    int i = -1;
    System.out.println("石头人快放大!!!");
    i = 1if(i == 1){
    	System.out.println("666");
    }
    //输出结果为666
    

    2.if-else条件语句

    格式:if(条件表达式){
              执行语句;
          }else {
              执行语句;
          }
    

    还是以一个例子来简单说明,完成程序如下:如果张三玩的石头人没有空大,那么队友就会跟他说666,否则,队友就会说可惜了,代码如下:

    //如果石头人没有空大则i为1,默认为-1
    int i = -1;
    System.out.println("石头人快放大!!!");
    if(i == 1){
    	System.out.println("666");
    }else{
    	System.out.println("可惜了");
    }
    //输出结果为可惜了
    

    3.if-else-if嵌套条件语句

    格式:if(条件表达式){
              执行语句;
          }else if(){
              执行语句;
          }else {
              执行语句;
          }
    

    if-else语句嵌套可以控制多个条件,完成程序如下:如果张三玩的石头人没有空大,那么队友就会跟他说666,如果R中2个,队友就会说不错,如果R中3个,队友就会说太棒了,否则,队友就会说可惜了,代码如下:

    //如果石头人空大默认为-1
    int i = -1;
    System.out.println("石头人快放大!!!");
    i = 3if(i == 1){
    	System.out.println("666");
    }else if(i == 2){
    	System.out.println("不错");
    }else if(i == 3){
    	System.out.println("太棒了");
    }else{
    	System.out.println("可惜了");
    }
    //输出结果为太棒了
    

    需要的注意问题
      1.如果if只有一条执行语句,那么括号可省略不写,但是为了程序编码规范,一般习惯一条语句也加上括号
      2.if-else的隐性条件判断,如果if的条件a > 60不成立,那么执行else执行语句的a变量相当于是a <= 60

    4.switch-case语句

    格式:switch(变量或变量表达式){
              case 值1:
              		  语句体;//可选加break;
              case 值2:
              		  语句体;//可选加break;
              case 值3:
              		  语句体;//可选加break;
              //可选加default;
          }
    
        switch(4){
            case 1:
                System.out.println("666");
                break;
            case 2:
                System.out.println("不错");
                break;
            case 3:
                System.out.println("太棒了");
                break;
            case 4:
                 System.out.println("真的厉害");
                 break;
            case -1:
                 System.out.println("可惜了");
                 break;
            default:
            	 System.out.println("大招冷却呢");
            }
            //输出结果:真的厉害
    

    需要的注意问题
      1.switch 语句中的变量类型可以是: byte、short、int、char、String
      2.case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量、或常量的计算表达式(如1+2等)
      3.case中如果有匹配的值则执行相应的语句,依次向下执行,直到结束或者遇到break语句,如果没有相匹配的值则执行default语句,如果再没有default的话则跳出switch语句
      4. default语句可以在任何位置,但建议在最后一个

    二、循环结构

      循环结构有while、do while以及for,掌握循环语句要拿准三个要素,第一个是初始化变量赋值,也就是我们循环开始的地方,第二个是判断循环是否继续进行的条件,这点很重要,第三个是每一次循环结束后,控制循环的变量的变化,下面我们来具体介绍下

    1.while循环语句

    格式:while(条件判断语句){循环体;}
    

    以循环输出1-100的数的和为例,来具体介绍下循环语句的应用方法,代码如下:

    //循环输出1-100的和
    //一、初始化变量赋值,首先要想一下,我们要求一个1-100的和,首先得有一个变量
    //去成为这个和,还要有一个变量去把自身加给这个和,一共有两个变量,这也是
    //写循环语句的第一步,初始化变量赋值
    int sum = 0;
    int m = 1;
    //二、判断循环是否继续进行的条件,因为我们要求的是1-100以内的和,所以
    //在大于100的时候结束循环
    while(m <= 100){
    sum += m;
    //三、控制循环的变量变化,我们要求的是1-100的和,所以每次只需要加1即可,
    //如果求得是1-100的奇数和,那么就可以写成m += 2
    m++;
    }
    System.out.println(sum);
    //输出结果为5050
    

    2.do-while循环语句

    格式:do{
    		循环体;
    	}while(条件判断语句)
    
    int i2 = 1;
    int num2 = 0;
    //无需判断条件直接执行第一步
    do {
    	num2 += i2;
    	i2++;
    }while (i2 <= 100);
    System.out.println(num2);
    //输出结果为5050
    

    需要的注意问题
      1.do while与while循环的最根本的区别是do while循环相当于把循环语句的第一次循环拿出来直接执行一次,且不需要判断条件,而while循环从第一步开始就需要判断条件,也就是说无论如何do while循环至少执行一次

    3.for循环语句

    for循环相当于把初始化变量赋值,判断语句,控制条件语句整合到了一起,非常方便,也是今后编程中最常用的循环

    格式:for(初始化语句;判断语句;条件控制语句){
                循环体语句;
         }
    

    执行流程:
      1.执行初始化语句
      2.执行判断语句,如果是true,继续执行,false循环结束
      3.执行循环体语句
      4.执行条件控制语句
      5.回到第二步

    //循环输入1-100的和
    int num = 0;
    for (int i = 0; i <= 100; i++) {
    num += i;
    System.out.println(num);
    }
    //输出结果为5050
    

    需要的注意问题
      1.for循环语句的控制很灵活,两个分号的左右以及中间部分可以按需填写,也可以不写
      2.在任意位置使用break语句后会跳出当前的大循环(考虑到循环嵌套),使用continue 语句会使程序立即跳转到条件控制语句

    三、循环嵌套(打印九九乘法表)

      循环嵌套对于很多初学者来说是一个难点,但其实也很好理解,只要找到外部循环与内部循环的关系即可轻松掌握,下面通过几个例子来带大家更好的掌握循环嵌套,先举一个例子:一开始我要跑十圈,代码如下:

    for (int i = 1; i <= 10; i++) {
    System.out.println("这是我跑的第" + i + "圈");
    }
    

      之后我每跑一圈做十个俯卧撑,然后我再跑下一圈,再做十个俯卧撑, 这里跑十圈是一个循环,而在这十圈之内,我每一圈又做了十个俯卧撑,这就相当于在跑圈这个循环之中又嵌套了一个做俯卧撑的循环,其中跑十圈是外部循环,做俯卧撑是内部循环,代码如下:

    //循环嵌套
    //跑十圈,每一圈做十个俯卧撑
    for (int i = 1; i <= 10; i++) {
    	System.out.println("这是我跑的第" + i + "圈");
    	//假设现在i为1,也就是我现在是在跑第一圈的过程中,接下来
    	//我要做俯卧撑了
    	for (int j = 1; j <= 10; j++) {
    	//此时i一直为1,j由1-10,直到该循环结束
    		System.out.println("这是我跑第" + i +"圈" +
    		+ ",做的第" + j +"个俯卧撑");
    	}
    	//到这里我才跑完第一圈,做完十个俯卧撑,接下来i++,开始
    	//第二轮外部循环
    }
    

      通过上面的例子,我们可以轻松的打印出九九乘法表,在这里外部循环i相当于控制了行数,内部循环j相当于控制了列数,这里的外部循环相当于我们在跑圈,内部循环相当于在跑每一圈的时候做的俯卧撑
      观察下图可知,九九乘法表一共有九行,相当于我们跑了九圈,跟我们只跑圈的代码一样,相当于改成了跑九圈

    for (int i = 1; i <= 9; i++) {
    System.out.println("这是我跑的第" + i + "圈");
    }
    

    九九乘法表
      而内部循环就不是每一圈做10个俯卧撑了,这个时候就要观察内部循环和外部循环之间的联系,我们发现,我们跑的圈数跟我们做的俯卧撑数一样,第1圈做1个,第2圈做2个,第3圈做3个…那么这个时候我们的判断条件就要改一下了,也就是,我们每一圈做的俯卧撑数最多和圈数相同,也就是内部循环的变量j(俯卧撑数)要<=外部循环的变量(圈数)
      之前我们的循环嵌套是要做俯卧撑,而现在我们是要打印九九乘法表,这个时候在观察九九乘法表,发现前面的数×后面的数就是俯卧撑数×圈数,也就是内部变量×外部变量,这下我们就可以轻松写出打印九九乘法表的代码:

    //打印九九乘法表
    for (int i = 1; i <= 9; i++) {
    	for (int j = 1; j <= i; j++) {
    		System.out.print(j + "×" + i + "=" + i * j + "\t");
    	}
    	System.out.println();
    }
    

    在这里插入图片描述

    总结

    本节主要介绍了Java的分支结构、循环结构和循环嵌套,详细讲解了如何打印出九九乘法表,希望对各位有所帮助

    展开全文
  • 1.选择结构 a):选择结构主要是: If(布尔表达式1){//true则执行代码块,...if语句支持嵌套。 例: 根据自己的购买力买车: 如果有500万,买劳斯莱斯; 否则,如果有100万,买GTR; 否则,如果有50万,买奔驰E; 否...

    1.选择结构

    a):选择结构主要是:
    If(布尔表达式1){//true则执行代码块,false跳过
    代码块1
    }else if(布尔表达式2){
    代码块2
    }
    注意:

    • else类似于else if;
    • 模块间相互排斥,一个为true,其它不执行。
    • if语句支持嵌套。

    例:
    根据自己的购买力买车:
    如果有500万,买劳斯莱斯;
    否则,如果有100万,买GTR;
    否则,如果有50万,买奔驰E;
    否则,如果有20万,大众帕萨特;
    否则,如果有10万,哈弗H6;
    否则,如果有5万,奇瑞QQ;
    否则,如果有1万,电动车;
    否则,捷安特自行车。

    		int money = 100; //万元
    		if(money >= 500){
    			System.out.println("劳斯莱斯");
    		}else if(money >= 100){
    			System.out.println("买GTR");
    		}else if(money >= 50){
    			System.out.println("奔驰E");
    		}else if(money >= 20){
    			System.out.println("大众帕萨特");
    		}else if(money >= 10){
    			System.out.println("哈弗H6");
    		}else if(money >= 5){
    			System.out.println("奇瑞QQ");
    		}else{
    			System.out.println("捷安特自行车");
    		}
    		System.out.println("程序结束...");
    

    2. 分支结构

    switch(变量/表达式){
    case 值1://true则执行代码块,false跳过
    代码块1;
    break;//跳出分支结构
    case 值2:
    代码块2;
    break;//跳出
    default:
    未满足条件时的逻辑代码;
    break;
    }
    注意: break跳出的位置很重要。
    例:
    判断一个整数,如果是1~5之间,则分别输出5个福娃的名字,否则输出“北京欢迎你”。
    答:

    int a=3;//1~5之间数字
    switch(a){
    		case 1:
    			System.out.println("贝贝");
    			break;
    		case 2:
    			System.out.println("晶晶");
    			break;
    		case 3:
    			System.out.println("欢欢");
    			break;
    		case 4:
    			System.out.println("迎迎");
    			break;
    		case 5:
    			System.out.println("妮妮");
    			break;
    		default:
    			System.out.println("北京欢迎你");
    			break;
    }
    

    3. 循环结构

    a):while循环:
    初始部分;
    while(循环条件){//直到条件变化为false,才结束。
    操作部分;
    迭代部分;
    }
    注意: 与条件相关的才是初始部分和迭代部分,有入口条件,先判断,再执行,执行0~n次。适用循环于次数明确的。

    例:计算1+2+3+…+100的和

    		int s = 0;//和
    		int i = 1;
    		while(i <=100){
    			s = s + i;
    			i++;
    		}
    		System.out.println(s);
    

    b):do while循环:
    初始部分;
    do{
    操作部分;
    迭代部分;
    }while(条件部分);//直到条件变化为false,才结束。
    注意: 无入口条件,先执行,再判断,执行1~n次。使用于循环次数不明确的。

    例:计算1+2+3+…+100的和

    		int s = 0;//和
    		int i = 1;
    		do{
    			s = s + i;
    			i++;
    		}while(i <= 100);
    		System.out.println(s);
    

    c):for循环
    for(初始部分;循环条件;迭代部分){//直到条件变化为false,才结束。
    循环操作
    }
    注意: 可以把初始部分和迭代部分写在别的位置,但是要保留分号。

    例:计算1+2+3+…+100的和

    		int s = 0;//和
    		for(int i = 1;i <= 100;i++){
    			s = s + i;
    		}
    		System.out.println(s);
    

    4. 循环嵌套

    概念:在一个完整的循环中嵌套另一个循环

    正常情况打印图形
    外层代表循环次数外层代表行
    内层代表单次循环操作内层代表列

    补充:嵌套循环约定成俗的变量命名:一重循环i;二重循环j;三重循环k。

    附:流程控制

    break :

    • 跳出,终止 选择循环或循环结构;
    • 可以判断 在循环出错的时候跳出循环
    • 可以为某循环加标记,使用 break 标记名; 跳出对应循环
      continue:
      结束本次循环操作,继续执行下一次循环。
    展开全文
  • C语言分支循环嵌套语句

    千次阅读 多人点赞 2021-10-12 22:47:18
    forever之前给大家介绍了C语言的分支结构和循环结构,在分支中介绍了分支语句嵌套,但当时没有介绍 switch 嵌套,所以这次主要介绍 switch 嵌套和循环嵌套. 首先来说说什么是嵌套吧!一个语句内包含另一个完整的...

    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

    展开全文
  • 分支结构switch、循环结构:for、嵌套循环for、break、continue一、分支结构switch二、循环结构1:for三、Day04 -- 循环+数组四、拓展 一、分支结构switch 1、概述 也像if一样,可以完成先判断的需求 也支持 byte ...
  • 分支结构+循环结构

    2021-10-14 15:38:39
    我们自从开始写Java代码,就一直说方法方法,main方法...如果有某一行代码或者某些行代码需要重复的执行若干次,这样的结构叫做循环结构 for循环 while循环 do…while循环(了解) foreach循环(增强for循环) 2.分支结构(重点
  • 一、循环结构 1、while语句: 适用范围比for广,其一般形式为: while(表达式){ 循环体语句 } 表达式为while循环为真的情况,循环终止并执行while的下一条语句。 使用方法: 1)while语句的表达式可以是任意合法的...
  • Python循环结构 1.引入库 2.读入数据 总结 Python分支结构 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文...
  • 1)单分支结构分支结构分支结构中最简单的一种方式,它的使用方法如下:if :单分支结构只需要判断一个条件,根据这个条件是否成立来决定是否执行一段语句。实例1:猜数字num_in=eval(input("请输入数字:"))if ...
  • 循环语句—循环嵌套

    2022-04-13 09:42:39
    5.循环嵌套 (学完循环嵌套要求知道循环嵌套的格式和执行流程) 5.1循环嵌套概述 语句结构: 顺序语句: ①以分号结尾,表示一句话的结束; 分支语句: ①一对大括号表示if的整体结构,整体描述一个完整的if...
  • <p>Python绘制上图要求使用turtle库绘制代码要怎样 <p style="text-align:center"><img alt="" height="148" src=... 包括分支结构和循环结构,提交源代码</p>
  • 目录逻辑结构顺序结构选择结构if语句 逻辑结构 顺序结构 顺序结构就是代码根据代码的顺序一行一行的执行。 例: 输出结果: 选择结构 if语句
  • 分支结构循环结构1. 无限循环2. 遍历循环3.条件循环4. 嵌套循环 程序基本结构 1.顺序结构 顺序结构的程序设计是最简单的,只要按照解决问题的顺序写出相应的指令就行,它的执行顺序是自上而下,依次执行。右面的...
  • 分支结构(if语句)1.三种结构:ifif elseif elif else计算当前日期与生日的关系,使用三层的if结构.import datetime#pytho自带的库,可以进行日期,时间的运算#打印今天的日期print('今天的日期:',datetime.date.today())...
  • 分支结构和循环结构

    2018-12-13 00:07:48
    分支结构   在C语言,if语句的写法应该是这样的 if(条件判断) { ... ... } 在python稍有不同,第一条件判断不用打括号,当然打括号也没有关系,第二没有花括号,那没有花括号的话,那怎么判断哪些是if...
  • python中嵌套循环练习题

    千次阅读 2020-12-18 12:24:28
    python中嵌套循环练习题1.打印九九乘法表:方法一:for i in range(1,10):for j in range(1,10):print(f’{i}{j}={i * j}’, end=’\t’)print()方法二:for i in range(1, 10):for j in range(1, i+1):print(str(j)...
  • 一.条件语句条件语句可以给定一个判断条件,并在程序执行过程判断该条件是否成立。...1.if语句if结构:满足条件就执行某个操作,不满足就不执行。语法: if 条件语句: 代码段# 如果num是奇数打印'奇数'num = ...
  • 一、MATLAB 流程控制结构、 二、for 循环、 1、for 循环、 2、嵌套 for 循环、 三、while 循环、 二、分支结构、 1、if end 分支结构、 2、if else end 分支结构、 3、switch case end 分支结构
  • 1、分支结构 if语句:1⃣️判断一个条件,如果这个条件成立,就执行其包含的某条语句或某个代码块。 2⃣️判断一个条件:如果条件成立,就执行其包含的某条语句或某个代码块;如果条件不成立,就执行另外的某条...
  • 麻烦提供书名和作者,感谢】Python3.6之for循环嵌套撰写代码第1个代码 :foriinrange(0,4):forjinrange(0,7):print("*",end="")print()说明:外循环用变量 i,一共打印4行:即:当i=0时,打印第1行,i=1时,打印第2...
  • 1. 分支结构1.1 应用场景迄今为止,我们写的Python代码都是一条一条语句顺序执行,这种代码结构通常称之为顺序结构。然而仅有顺序结构并不能解决所有的问题,比如我们设计一个游戏,游戏第一关的通关条件是玩家获得...
  • 有些事情需要重复不断的去执行(当满足某种条件或不满足某种条件结束重复动作):循环结构 ''' ``` ## if分支结构 ```python ''' if 条件: 同缩进的代码块 ''' if age > 18: print("") if age > 30: print("") elif ...
  •  (2)循环结构包括while循环和for循环(3)对于不知道循环次数但知道循环条件的用while循环。知道循环次数不知道循环条件用for循环。(4)在进行循环处理的时候有两个关键字:continue,break;continue:会跳过循环体的...
  • 本次实验的内容延续第一次实验内容,将 BCD 码转换为二进制码,相关内 容参看第一次实验的表格。 在各种智能仪器和信息处理,人们总习惯于十进制数来表示信息。但是绝 大多数计算机没有十进制运算指令(仅有十...
  • 1.流程控制分为:顺序结构、分支结构、循环结构 顺序结构:严格从上往下,从左往右 分支结构:分为单分支和双分支、多分支,通过指定的判断条件,选择性执行不同分支;多分支 循环结构:重复执行某些代码很多次 2.各...
  • 分类(1)顺序结构(2)分支结构(3)循环结构二、分支结构1.if语句2.switch三、循环结构1.概述2.分类3.for循环4.多重循环5.while循环6.do...while循环 流程控制 一、流程控制概念 1.什么是流程控制 使用不同的...
  • Python选择结构和循环结构

    千次阅读 多人点赞 2020-03-20 23:19:10
    在选择和循环结构中,条件表达式的值只要不是False、0(或0.0、0j等)、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象,Python解释器均认为与True等价。 (1)关系运算符 ...
  • 1.分支结构和循环结构----的代码练习! 一.分支结构 在Python,要构造分支结构可以使用if、elif和else关键字。所谓关键字就是有特殊含义的单词,像if和else就是专门用于构造分支结构的关键字,很显然你不能够使用...
  • 分支结构、双分支结构、多分支结构
  • for循环嵌套里怎幺用if语句控制外循环?修改如下int Su(int x){int i,j;for(i=x;i>=2;i--){for(j=2;j<=i>=i>{if(i%j==0) {break;} //若能整除任何一个数,说明非素数,跳出内循环,检查下一个i}if(j>i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,863
精华内容 17,545
热门标签
关键字:

循环结构中嵌套分支

友情链接: Drug-stocks.zip