Java编程—流程控制综合示例

 

          在遇到一个实际问题时，首先要能够思考出解决这个问题的数学步骤或逻辑步骤，然后才能编写对应的代码，所以遇到实际问题是，一定要积极思考，并且善于思考，对于一个相同的问题，不同的逻辑就可以写出不同的代码，所以在思考解决问题的方式时，需要进行发散性的思维，而这些理性的思维很多都是建立在数学基础以及对语法的熟悉基础之上。

         下面，通过一系列的实际问题，来说明解决实际问题的步骤以及书写的对应的代码。

 

 示例讲解

 

1、 最大公约数

    问题：求两个自然数的最大公约数。

    这两个都是基础的数学问题，最大公约数指两个数字公共的约数中最大的，例如数字6的约数有1、2、3、6，数字9的约数有1、3、9，则数字6和数字9的公共约数有1和3，其中3是最大的公约数。

    第一种思路：从1开始循环，每次把符合要求（即同时是两个数字的约数）的值都存储起来，那么最后一个存储起来的就是最大的约数。

    则实现的代码如下：

                   int n = 6;

                   int m = 9;

                   int result = 1;

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

                            if((n % i == 0) && (m % i == 0)){

                                     result = i;

                            }

                   }

                   System.out.println(result);

    使用该思路，每次都存储得到的公共约数，那么最后一个存储的就是两个数字的最大公约数。

    第二种思路：从两个数字中最小的数字开始循环，每次减1，那么第一次得到的公共约数就是所求的最大公约数。

    则实现的代码如下：

                   int n = 6;

                   int m = 9;

                   int result = n > m ?m : n;

                   for(int i = result;i >= 1;i--){

                            if((n % i == 0) && (m % i == 0)){

                                     result = i;

                                     break; //结束循环

                            }

                   }

                   System.out.println(result);

    当然，解决这个问题，还有很多其它的方法，这里演示的这两种实现只是最自然的实现而已，采用类似的原理也可以求两个数字的最小公倍数的结构。

 

2、 百元百鸡问题

    问题描述：每只母鸡3元，每只公鸡4元，每只小鸡0.5元，如果花100元钱买100只鸡，请问有哪些可能？说明：每种鸡的数量都可以为零。

    其实这个问题是数学上的组合问题，只需要把所有的情况列举出来，然后来判断是否符合要求即可。这样的重复列举的问题，在程序上可以使用循环进行解决。

    第一种思路：当母鸡的数量为0时，公鸡的数量从0-100，当公鸡的数量每变化一次，小鸡的数量就从0变化到100，使用如下数值组合来描述这个思路：

                  母鸡数量                            公鸡数量                            小鸡数量

                      0                                               0                                   从0变化到100

                      0                                               1                                   从0变化到100

                      0                                               2                                   从0变化到100

                   ……

                      1                                               0               从0变化到100

                      1                                               1                                   从0变化到100

                   ……

                      100                                     100                              100

    上面列举出了所有公鸡、母鸡和小鸡的数量都是0-100时的所有组合，总计是101的三次方种，这样的穷举结构直接存在嵌套，在程序实际实现时，通过循环之间的嵌套就可以实现，则实现的代码如下：

                   for(int i = 0;i <= 100;i++){ //母鸡数量

                            for(int j = 0;j <= 100;j++){ //公鸡数量

                                     for(int k = 0;k <= 100;k++){ //小鸡数量

                                               //判断数量是否为100，以及金额是否为100

                                               if((i +j + k == 100) && (i * 3 + j * 4 + k * 0.5 == 100)){

                                                        System.out.println(“母鸡数量：” + i + “ 公鸡数量：” + j + “ 小鸡数量” + k);

                                               }

                                     }

                            }

                   }

    按照for语句的执行流程，循环变量变化1，则内部的循环执行一次，而在循环嵌套时，循环体又是一个新的循环，则该循环执行完成的一组循环。这里通过循环的嵌套实现了所有数值的穷举。在循环的内部，只需要按照题目要求判断一下数量和金额是否符合要求即可。

    但是这样的代码效率比较差，可以通过简单的优化来提高程序的执行效率。

    第二种思路：由于母鸡每只的金额是3元，所以100元最多购买的母鸡数量是100/3=33只，同理100元最多购买的公鸡数量是25只，而按照100元100只的要求，小鸡的数量应该为100减去公鸡和母鸡的数量，这样代码就可以简化为如下的结构：

                   for(int i = 0;i <= 33;i++){ //母鸡数量

                            for(int j = 0;j <= 25;j++){ //公鸡数量

                                     int k = 100 –i – j; //小鸡数量

                                               //判断金额是否为100

                                               if (i * 3 + j * 4 + k * 0.5 == 100){

                                                        System.out.println(“母鸡数量：” + i + “ 公鸡数量：” + j + “ 小鸡数量” + k);

                                               }

                                     }

                            }

                   }

    这样，就可以大幅提高程序的执行效率，从而提高程序的执行速度。当然该代码还可以继续进行优化，那样可以再次提供程序的执行效率。

 

 

3 、喝汽水问题

    问题：共有1000瓶汽水，每喝完后一瓶得到的一个空瓶子，每3个空瓶子又能换1瓶汽水，喝掉以后又得到一个空瓶子，问总共能喝多少瓶汽水，最后还剩余多少个空瓶子？

    这个问题其实是个比较典型的递推问题，每3个空瓶都可以再换1瓶新的汽水，这样一直递推下去，直到最后不能换到汽水为止。

    第一种思路：每次喝一瓶，每有三个空瓶子就去换一瓶新的汽水，直到最后没有汽水可以喝为止。在程序中记忆汽水的数量和空瓶子的数量即可。

    则实现的代码如下：

                   int num = 1000;        //汽水数量

                   int drinkNum = 0;      //喝掉的汽水数量

                   int emptyNum = 0;    //空瓶子的数量

                   while(num > 0){       //有汽水可以喝

                            num--;         //喝掉一瓶

                            emptyNum++; //空瓶子数量增加1

                            drinkNum++;   //喝掉的汽水数量增加1

                            if(emptyNum == 3){ //有3个空瓶子，则去换

                                     num++;   //汽水数量增加1

                                     emptyNum = 0;   //空瓶子数量清零

                            }

                   }

                   System.out.println(“总共喝掉瓶数：” + drinkNum);

                   System.out.println(“剩余空瓶子数：” + emptyNum);

    执行该程序，输出结果如下：总共喝掉瓶数：1499剩余空瓶子数：2在该代码中，每次循环喝掉一瓶汽水，则汽水数量减少1，空瓶子数增加1，喝掉的总汽水瓶数增加1，每次判断空瓶子的数量是否达到3，如果达到3则换1瓶汽水，同时空瓶子的数量变为零。这种思路比较直观，但是循环的次数比较多，所以就有了下面的逻辑实现。

    第二种思路：一次把所有的汽水喝完，获得所有的空瓶子，再全部换成汽水，然后再一次全部喝完，再获得所有的空瓶子，依次类推，直到没有汽水可喝为止。

    则实现的代码如下：

                   int num = 1000;       //汽水数量

                   int drinkNum = 0;     //喝掉的汽水数量

                   int emptyNum = 0;    //空瓶子的数量

                   while(num > 0){      //有汽水可以喝

                            drinkNum += num; //喝掉所有的汽水

                            emptyNum += num; //空瓶子数量等于上次剩余的加上这次喝掉的数量

                            num = emptyNum / 3; //兑换的汽水数量

                            emptyNum -= num * 3; //本次兑换剩余的空瓶子数量

                   }

                   System.out.println(“总共喝掉瓶数：” + drinkNum);

                   System.out.println(“剩余空瓶子数：” + emptyNum);

    在该代码中，每次喝掉所有的汽水，也就是num瓶，则喝掉的总瓶数每次增加num，因为每次都可能剩余空瓶子（不足3个的），则总的空瓶子数量是上次空瓶子数量加上本次喝掉的num瓶。接着是对话汽水，则每次可以兑换的汽水数量是空瓶子的数量的1/3，注意这里是整数除法，而本次兑换剩余的空瓶子数量是原来的空瓶子数量减去兑换得到汽水数量的3倍，这就是一次循环所完成的功能，依次类推即可解决该问题。

 

4、水仙花数

    问题：水仙花数指三位数中，每个数字的立方和和自身相等的数字，例如370，3 × 3 × 3 + 7 × 7 × 7 + 0 × 0 × 0 =370，请输出所有的水仙花数。

    该问题中体现了一个基本的算法——数字拆分，需要把一个数中每位的数字拆分出来，然后才可以实现该逻辑。

    实现思路：循环所有的三位数，拆分出三位数字的个位、十位和百位数字，判断3个数字的立方和是否等于自身。

    则实现的代码如下所示：

                   for(int i = 100;i < 1000;i++){ //循环所有三位数

                            int a = i % 10;         //个位数字

                            int b = (i / 10) % 10; //十位数字

                            int c = i / 100;       //百位数字

                            //判断立方和等于自身

                            if(a * a * a + b * b * b + c * c * c == i){

                                     System.out.println(i);

                            }

                   }

    在该代码中，拆分个位数字使用i和10取余即可，拆分十位数字时首先用i除以十，去掉个位数字，并使原来的十位数字变成个位，然后和10取余即可，因为i是一个三位数，所以i除以100即可得百位数字，因为这里都是整数除法，不存在小数的问题。然后只需要判断立方和是否等于自身即可。

    注意：因为i是循环变量，这里不能改变i的值，不然可能造成死循环。

 

5 、99乘法表

    问题：在控制台打印数学上的99乘法表

    该类问题是发现数字的规律，然后将数值的规律用程序描述出来。实际实现时，可能需要耐心的进行调试。在这里，需要实现数字的多行输出，前面使用的System.out.println是输出内容并换行，后续再输出的内容就再下一行显示，如果需要在输出时不换行，则可以使用System.out.print进行输出。

    99乘法表的规则是总计9行，每行单独输出，第一行有1个数字，第二行有2个数字，依次类推，数字的值为行号和列号的乘积。

    实现思路：使用一个循环控制打印9行，在该循环的循环体中输出该行的内容，一行中输出的数字个数等于行号，数字的值等于行号和列号的成绩。

    实现代码如下：

    for（int row = 1；row <= 9；row++）{       //循环行

    for（int col = 1；col <= row；col++）{   //循环列

    System.out.print（row * col）； //输出数值

    System.out.print（' '）；        //输出数字之间的间隔空格

    }

    System.out.println（）；           //一行输出结束，换行

    }

    该程序的输出为：

    1

    2 4

    3 6 9

    4 8 12 16

    5 10 15 20 25

    6 12 18 24 30 36

    7 14 21 28 35 42 49

    8 16 24 32 40 48 56 64

    9 18 27 36 45 54 63 72 81

    在该输出中，数字之间的对齐有些问题，第四行和第五行的对齐就很明显。那么如果在输出时想让数字对齐，那么就要首先思考数字为什么不能对齐？则问题直观的出现在有些数字是一位数有些是两位数，发现了原因就可以着手解决了，如果想实现数字的左对齐，则在一位数字的后续多输出一个空格，如果想实现数字的右对齐，则只需要在一位数字的前面输出一个空格即可。

    以下代码实现了数字的右对齐：

    for（int row = 1；row <= 9；row++）{       //循环行

    for（int col = 1；col <= row；col++）{   //循环列

    if（row * col < 10）{     //一位数

    System.out.print（' '）；

    }

    System.out.print（row * col）； //输出数值

    System.out.print（' '）；        //输出数字之间的间隔空格

    }

    System.out.println（）；           //一行输出结束，换行

    }

    所以在实际书写代码时，代码的位置对于程序逻辑的影响很大，在编写代码时，需要认真考虑代码书写的位置。

 

6 、打印图形

    问题：在控制台中打印如下格式的图形

    *

    ***

    *****

    *******

    *********

    由于受到控制台输出的限制，只能按照行的上下，依次进行输出，所以解决打印图形的问题时，只能按照从上到下依次输出每行的内容，关键是仔细观察，发现图形的规律。

    第一种思路：外部循环循环5次打印5行，每行的内容分为两部分：空格和星号，每行空格的数量是5减去行号个，每行星号的数量是行号的2倍减1个，在外部循环内部先打印空格，再打印星号，每个都只打印1个，使用数量控制对应的打印次数，打印完星号以后换行。

    则实现的代码如下：

    for（int row = 1；row <= 5；row++）{      //循环行

    //打印空格

    for（int c1 = 0；c1 < 5 - row；c1++）{

    System.out.print（' '）；

    }

    //打印星号

    for（int c2 = 0；c2 < 2 * row - 1；c2++）{

    System.out.print（'*'）；

    }

    //换行

    System.out.println（）；

    }

    该代码中row的循环用于控制打印的行数，row变量的值代表行号，内部的循环体分为三部分：打印空格，打印星号和换行，打印的数量参看图形的规律部分。

    第二种思路：外部循环循环5次打印5行，内部每行打印的总字符数量是4加行号个，其中前5-行号个字符是空格，后续的字符是星号，所有字符打印完成以后换行。

    则实现的代码如下：

    for（int row = 1；row <= 5；row++）{      //循环行

    //循环总的字符数

    for（int col = 0； col < 4 + row；col++）{

    if（col < 5 - row）{ //打印空格

    System.out.print（' '）；

    }else{ //打印星号

    System.out.print（'*'）；

    }

    }

    //换行

    System.out.println（）；

    }

    该代码的总体思路和第一种思路一样，都是按行打印，只是在考虑问题时首先考虑字符总的数量，把这个数量作为循环次数，内部控制那些该输出字符那些该输出星号即可。

 

7、 质数判断问题：判断一个自然数是否是质数。

    质数指只能被1和自身整除自然数，也称素数，最小的质数是2.对于自然数来说，任何一个数字都可以被1和自身整除。

    实现思路：利用数学上的反证法进行判断。则问题转换为只需要判断不能被1和自身以外的任何一个数字整除即可。则假设判断的数字是n的话，则这些数字的区间是[2，n-1]和大于n的所有数字。在数学上n不可能被大于n的数字整除，所以程序只需要判断[2，n-1]之间的数字即可，如果被该区间的任何一个数字整除了，则说明不是质数。

    则实现的代码如下：

    int n = 23；

    boolean b = true； //存储是否是质数，假设是质数

    for（int i = 2；i < n；i++）{

    //如果整除，则不是质数

    if（n % i == 0）{

    b = false；

    break；     //后续比较没有意义，结束循环

    }

    }

    //输出是否是质数

    if（b）{

    System.out.println（"是质数"）；

    }else{

    System.out.println（"不是质数"）；

    }

    该代码是最容易思考出来的一种实现，其实在数学上只需要判断n是否可以被2到n的二次方根之间的数字即可。则实现的代码变为如下：

    int n = 23；

    boolean b = true； //存储是否是质数，假设是质数

    for（int i = 2；i <= Math.sqrt（n）；i++）{

    //如果整除，则不是质数

    if（n % i == 0）{

    b = false；

    break；     //后续比较没有意义，结束循环

    }

    }

    //输出是否是质数

    if（b）{

    System.out.println（"是质数"）；

    }else{

    System.out.println（"不是质数"）；

    }

    通过缩小判断数字的区间，可以显著提高程序的执行效率。说明：这里的Math.sqrt的功能是计算n的二次方根。

 

 

8、综合练习

    本部分是一些整理的关于流程控制部分的综合练习，可以通过这些练习熟悉Java语言的基本语法，以及锻炼逻辑思维能力。

    练习题：1、 计算数字12和18的最小公倍数。

    2、 如果苹果 1元/个， 桔子 2 元/个， 芒果 4元/个，若是用10元去买，有几种组合呢？

    3、 一只猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个，第10天早上想再吃时，发现只剩下一个桃子了。请问猴子第一天一共摘了多少个桃子？

    4、 计算30的阶乘。

    5、 一个农场有头母牛，现在母牛才一岁，要到四岁才能生小牛，四岁之后，每年生一头小牛。假设每次生的都是母牛，并且也遵守4年才生育并生母牛的原则，并且无死亡，请问n年后共有多少头牛？

    6、 角谷猜想问题：日本一位中学生发现一个奇妙的“定理”，请角谷教授证明，而教授无能为力，于是产生角谷猜想。猜想的内容是：任给一个自然数，若为偶数除以2，若为奇数则乘3加1，得到一个新的自然数后按照上面的法则继续演算，若干次后得到的结果必然为1.试编写代码验证该猜想是否正确。

    7、 输出20个如下规律的数列： 1 1 2 3 5 8 13……

    8、 输出30个如下规律的数列： 1 3 6 10 15 21 ……

    9、 输出任意一个三位数中的个位数字和百位数字对调的数值，例如如果三位数是235，则输出532.

    10、求100以内所有质数的和。