##################################################
目录
循环热身
前言
三种循环
数组循环接收数据并使用 for 循环遍历输出
利用 for 循环结构计算一组数据的平均分
初识二重循环
将此程序升级为二重循环
内循环处理数据
外循环处理数据
二重循环规律
利用二重循环解决鸡兔同笼问题
题目
运行效果
Java 代码
经典的冒泡排序
什么是冒泡排序
冒泡排序升序原理
如何实现
冒泡优点
冒泡测试程序示例
##################################################
循环热身
——————————
前言
我们有了 循环加数组 就等于
你强任你强、东皇墨子加张良。。
你骚任你骚、李白韩信加名刀。。
你秀继续秀、亚瑟典韦凯绕后。。
你狂继续狂、玄策阿珂兰陵王。。
肉到干不死?貂蝉吕布老夫子。。
残血追不到?哪吒诸葛元气炮。。
对面距离长?守约干将秦始皇。。
哈哈哈 想不到吧 突如其来的鬼畜。。
咯咯咯咯咯……
突如其来的骚 闪掉崽崽的腰!
哈哈哈哈哈……
不皮了 我们学会了用循环和数组解决问题
还会用循环解决需要重复执行的操作
我们还知道 if、switch 等结构 是可以嵌套使用的!
那 循环结构 是否也能嵌套呢?
蛮吉:那绝对是当然的!
噗噗噗 魁拔乱入。。
嵌套循环很有意思 能解决很多更有意思的问题!
——————————
三种循环
还记得循环的 3 种形式吗?
while 循环
do-while 循环
for 循环
单个循环 就是 一重循环
两个循环 就是 二重循环 当然这是指嵌套关系
二重循环 可以解决更复杂的问题
——————————
数组循环接收数据并使用 for 循环遍历输出
例如:
你今天买了五个东东
请以表格形式输出购物金额及总金额
test.java code:
import java.util.*;
public class test {
public static void main ( String[] args ) {
Scanner input = new Scanner(System.in);
double[] M = new double[5];
System.out.println ( "请输入 5 个物品购买记录 ");
for ( int i = 1; i <= M.length; M[i-1] = input.nextDouble(), i ++ )
System.out.print("第 "+ i +" 个物品金额 >>> ");
System.out.println ( "n序号ttt金额¥" );
for ( int i = 1; i <= M.length; i ++ )
System.out.println ( i + "ttt" + M[i - 1] );
System.out.println ( "n总金额 >>> "+
( M[0] + M[1] + M[2] + M[3] + M[4]) );
}
}
cmd demo:
C:UsersbymejavaTest>javac test.java C:UsersbymejavaTest>java test 请输入 5 个物品购买记录 第 1 个物品金额 >>> 10 第 2 个物品金额 >>> 20 第 3 个物品金额 >>> 30 第 4 个物品金额 >>> 40 第 5 个物品金额 >>> 50 序号 金额¥ 1 10.0 2 20.0 3 30.0 4 40.0 5 50.0 总金额 >>> 150.0 C:UsersbymejavaTest>java test 请输入 5 个物品购买记录 第 1 个物品金额 >>> 15 第 2 个物品金额 >>> 200.4 第 3 个物品金额 >>> 300.7 第 4 个物品金额 >>> 500.9 第 5 个物品金额 >>> 800.10 序号 金额¥ 1 15.0 2 200.4 3 300.7 4 500.9 5 800.1 总金额 >>> 1817.1 C:UsersbymejavaTest>
——————————
利用 for 循环结构计算一组数据的平均分
test.java code:
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] A;
int num = 0, sum = 0;
System.out.print ( "指定该数组长度n<<< " );
num = input.nextInt();
A = new int[num];
System.out.printf ( "请输入 %d 个 int <<< ", num );
for ( int i = 0; i < A.length; sum += A[i], i ++ ) {
A[i] = input.nextInt();
System.out.println ( "储存的第 [" + (i + 1) + "] 个数据为 >>> [" + A[i] + "]" );
}
System.out.println ( num + " 个数的平均分为 >>> " +
(double) sum / A.length);
}
}
cmd demo:
C:UsersbymejavaTest>javac test.java
C:UsersbymejavaTest>java test
指定该数组长度
<<< 10
请输入第 1 个 int 数据
<<< 10
储存的第 [1] 个数据为 >>> [10]
请输入第 2 个 int 数据
<<< 20
储存的第 [2] 个数据为 >>> [20]
请输入第 3 个 int 数据
<<< 30
储存的第 [3] 个数据为 >>> [30]
请输入第 4 个 int 数据
<<< 40
储存的第 [4] 个数据为 >>> [40]
请输入第 5 个 int 数据
<<< 50
储存的第 [5] 个数据为 >>> [50]
请输入第 6 个 int 数据
<<< 60
储存的第 [6] 个数据为 >>> [60]
请输入第 7 个 int 数据
<<< 70
储存的第 [7] 个数据为 >>> [70]
请输入第 8 个 int 数据
<<< 80
储存的第 [8] 个数据为 >>> [80]
请输入第 9 个 int 数据
<<< 90
储存的第 [9] 个数据为 >>> [90]
请输入第 10 个 int 数据
<<< 100
储存的第 [10] 个数据为 >>> [100]
10 个数的平均分为 >>> 55.0
C:UsersbymejavaTest>java test
指定该数组长度
<<< 10
请输入第 1 个 int 数据
<<< 10 20 30 40 50 60 70 80 90 100
储存的第 [1] 个数据为 >>> [10]
请输入第 2 个 int 数据
<<< 储存的第 [2] 个数据为 >>> [20]
请输入第 3 个 int 数据
<<< 储存的第 [3] 个数据为 >>> [30]
请输入第 4 个 int 数据
<<< 储存的第 [4] 个数据为 >>> [40]
请输入第 5 个 int 数据
<<< 储存的第 [5] 个数据为 >>> [50]
请输入第 6 个 int 数据
<<< 储存的第 [6] 个数据为 >>> [60]
请输入第 7 个 int 数据
<<< 储存的第 [7] 个数据为 >>> [70]
请输入第 8 个 int 数据
<<< 储存的第 [8] 个数据为 >>> [80]
请输入第 9 个 int 数据
<<< 储存的第 [9] 个数据为 >>> [90]
请输入第 10 个 int 数据
<<< 储存的第 [10] 个数据为 >>> [100]
10 个数的平均分为 >>> 55.0
C:UsersbymejavaTest>
##################################################
初识二重循环
%%%%%
将此程序升级为二重循环
先用循环解决一个问题
需求:
VIP 添加用户积分
接收一组用户积分
然后计算本组用户平均积分
test.java code && demo:
import java.util.*;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int W = 1;
double sum = 0.0;
int user[] = new int[5];
System.out.println ( "请输入 5 个用户的积分 当前第 " + W + " 组" );
for ( int i = 0; i < user.length; i ++ ) {
System.out.print ( "第 "+ (i + 1) +" 位用户的积分 <<< " );
user[i] = input.nextInt(); // 录入数据
sum = sum + user[i]; // 累加数据
}
System.out.println ( "本组用户平均积分为 >>> " + (sum / user.length) );
}
}
看 我们已经能够完成很 nb 很高大上的程序了
%%%%%
内循环处理数据
but 如果我们更改一下这个需求:
VIP 添加用户积分
接收 3 组用户各 5 名用户积分
然后计算每组用户平均积分
难道要写三个循环吗?
那如果 100 组用户呢? 100 个循环??
这个时候 二重循环 的魅力 就体现出来了!
用第一个循环 控制用户组数量
用第二个循环 控制单个组的用户数量
这就是 二重循环
简单的说 就是一个循环体内又包含另一个完整的循环结构
不一定只能嵌套一种循环 while、do-while、for 这三种循环当然也可以相互嵌套!
来试着解决升级版需求 code:
import java.util.*;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print ( "请输入一共有几组用户 <<< " );
int group = input.nextInt();
double sum[] = new double[group];
System.out.print ( "请输入每组有几个用户 <<< " );
int user_num = input.nextInt();
int user[] = new int[user_num];
System.out.println();
for ( int i = 0; i < sum.length; i ++ ) {
System.out.println ( "请输入 " + sum.length + " 个用户的积分 当前,第 " + (i + 1) + " 组" );
for ( int j = 0; j < user.length; j ++ ) {
System.out.print ( "第 "+ (j + 1) +" 位用户的积分 >>> " );
user[j] = input.nextInt();
sum[i] += user[j];
}
sum[i] /= user.length;
System.out.println ( "本组用户平均积分为 >>> " + sum[i] + "n" );
}
System.out.print ( "——————————"
+ "执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>>n" );
for ( double i : sum )
System.out.print ( i + "tn") ;
}
}
运行结果如下 以下结果都在 calc 程序中验证通过绝对正确 demo:
C:UsersbymejavaTest>javac test.java C:UsersbymejavaTest>java test 请输入一共有几组用户 <<< 4 请输入每组有几个用户 <<< 3 请输入 4 个用户的积分 当前,第 1 组 第 1 位用户的积分 >>> 2 第 2 位用户的积分 >>> 3 第 3 位用户的积分 >>> 4 本组用户平均积分为 >>> 3.0 请输入 4 个用户的积分 当前,第 2 组 第 1 位用户的积分 >>> 12 第 2 位用户的积分 >>> 23 第 3 位用户的积分 >>> 43 本组用户平均积分为 >>> 26.0 请输入 4 个用户的积分 当前,第 3 组 第 1 位用户的积分 >>> 35 第 2 位用户的积分 >>> 32 第 3 位用户的积分 >>> 14 本组用户平均积分为 >>> 27.0 请输入 4 个用户的积分 当前,第 4 组 第 1 位用户的积分 >>> 25 第 2 位用户的积分 >>> 43 第 3 位用户的积分 >>> 32 本组用户平均积分为 >>> 33.333333333333336 ——————————执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>> 3.0 26.0 27.0 33.333333333333336 C:UsersbymejavaTest>javac test.java C:UsersbymejavaTest>java test 请输入一共有几组用户 <<< 2 请输入每组有几个用户 <<< 5 请输入 2 个用户的积分 当前,第 1 组 第 1 位用户的积分 >>> 65 第 2 位用户的积分 >>> 76 第 3 位用户的积分 >>> 45 第 4 位用户的积分 >>> 76 第 5 位用户的积分 >>> 43 本组用户平均积分为 >>> 61.0 请输入 2 个用户的积分 当前,第 2 组 第 1 位用户的积分 >>> 43 第 2 位用户的积分 >>> 23 第 3 位用户的积分 >>> 76 第 4 位用户的积分 >>> 87 第 5 位用户的积分 >>> 56 本组用户平均积分为 >>> 57.0 ——————————执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>> 61.0 57.0 C:UsersbymejavaTest>
%%%%%
外循环处理数据
这次改成外循环中求平均数 code:
import java.util.*;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print ( "请输入一共有几组用户 <<< " );
int group = input.nextInt();
double SUM = 0.0;
double sum[] = new double[group];
System.out.print ( "请输入每组有几个用户 <<< " );
int user_num = input.nextInt();
int user[] = new int[user_num];
System.out.print ( "n——————————"
+ "执行完毕!此为实验阶段 主要查看遍历数组的信息 >>> n" );
for ( double i : sum )
System.out.print ( i +"t" );
System.out.println();
for ( int i : user )
System.out.print ( i +"t" );
System.out.println();
System.out.println();
for ( int i = 0; i < group; i ++ ) {
SUM = 0.0;
System.out.println ( "请输入 " + user_num + " 个用户的积分 当前,第 " + (i+1) + " 组" );
for ( int j = 0; j < user.length; j ++ ) {
System.out.print ( "第 " + (j + 1) + " 位用户的积分 >>> " );
user[j] = input.nextInt();
SUM = SUM + user[j];
}
sum[i] = SUM / user.length;
System.out.println ( "第 " + (i + 1) + " 组用户平均积分为 >>> "
+ sum[i] + "n" );
}
System.out.print("——————————"
+ "执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>> n");
for ( double i : sum )
System.out.print ( i + "t" );
}
}
得到相同的结果 demo:
C:UsersbymejavaTest>javac test.java C:UsersbymejavaTest>java test 请输入一共有几组用户 <<< 4 请输入每组有几个用户 <<< 3 ——————————执行完毕!此为实验阶段 主要查看遍历数组的信息 >>> 0.0 0.0 0.0 0.0 0 0 0 请输入 3 个用户的积分 当前,第 1 组 第 1 位用户的积分 >>> 2 第 2 位用户的积分 >>> 3 第 3 位用户的积分 >>> 4 第 1 组用户平均积分为 >>> 3.0 请输入 3 个用户的积分 当前,第 2 组 第 1 位用户的积分 >>> 12 第 2 位用户的积分 >>> 23 第 3 位用户的积分 >>> 43 第 2 组用户平均积分为 >>> 26.0 请输入 3 个用户的积分 当前,第 3 组 第 1 位用户的积分 >>> 35 第 2 位用户的积分 >>> 32 第 3 位用户的积分 >>> 14 第 3 组用户平均积分为 >>> 27.0 请输入 3 个用户的积分 当前,第 4 组 第 1 位用户的积分 >>> 25 第 2 位用户的积分 >>> 43 第 3 位用户的积分 >>> 32 第 4 组用户平均积分为 >>> 33.333333333333336 ——————————执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>> 3.0 26.0 27.0 33.333333333333336 C:UsersbymejavaTest>java test 请输入一共有几组用户 <<< 2 请输入每组有几个用户 <<< 5 ——————————执行完毕!此为实验阶段 主要查看遍历数组的信息 >>> 0.0 0.0 0 0 0 0 0 请输入 5 个用户的积分 当前,第 1 组 第 1 位用户的积分 >>> 65 第 2 位用户的积分 >>> 76 第 3 位用户的积分 >>> 45 第 4 位用户的积分 >>> 76 第 5 位用户的积分 >>> 43 第 1 组用户平均积分为 >>> 61.0 请输入 5 个用户的积分 当前,第 2 组 第 1 位用户的积分 >>> 43 第 2 位用户的积分 >>> 23 第 3 位用户的积分 >>> 76 第 4 位用户的积分 >>> 87 第 5 位用户的积分 >>> 56 第 2 组用户平均积分为 >>> 57.0 ——————————执行完毕!此为实验阶段 主要查看 sum[] 的信息 >>> 61.0 57.0 C:UsersbymejavaTest>
——————————
二重循环规律
现在 我们应该明白一个规律:
外层循环跑一趟
内层循环跑一遍
假如 外层循环 5 次 内层也是 5 次 外层跑 1 趟 内层跑 1 遍 就是外层跑 1 次 内层跑 5 次 当外层跑完 5 趟 循环结束 一共跑了 外层 5 次 内层 5 * 5 = 25 次 是不是很神奇?!
##################################################
利用二重循环解决鸡兔同笼问题
——————————
题目
需求:
古代数学家 张丘建 在《算经》中 出了一道 百钱买百鸡 的问题
5 文钱 可以买 1 只公鸡
3 文钱 可以买 1 只母鸡
1 文钱 可以买 3 只雏鸡
现在用 100 文钱买 100 只鸡 那么 公鸡、母鸡、雏鸡 各几只?
在古代这种一题多答的不多
——————————
运行效果
cmd demo:
C:UsersbymejavaTest>javac test.java C:UsersbymejavaTest>java test 公鸡_4 母鸡_18 雏鸡_78 公鸡_8 母鸡_11 雏鸡_81 公鸡_12 母鸡_4 雏鸡_84 C:UsersbymejavaTest>
——————————
Java 代码
test.java code:
import java.util.Scanner;
public class test {
public static void main(String[] args) {
int k = 0;
for ( int i = 0; i <= 20; i ++ ) {
for ( int j = 0; j <= 33; j ++ ) {
k = 100 - i - j;
if ( ( ( (5 * i) + (3 * j) + (k / 3.0) ) == 100 ) &&
( (i + j + k) == 100 ) &&
(i > 0) && (j > 0) && (k > 0)
)
System.out.println ( "公鸡_" + i + "t" +
"母鸡_" + j + "t" +
"雏鸡_" + k );
}
}
}
}
##################################################
经典的冒泡排序
——————————
什么是冒泡排序
举个栗子:
遍历比较数组中两个相邻的元素将值大的元素交换至右端
遍历比较数组中两个相邻的元素将值大的元素交换至左端
遍历比较数组中两个相邻的元素将值小的元素交换至右端
遍历比较数组中两个相邻的元素将值小的元素交换至左端
这些需求可以不用 Arrays.sort 方法而是复用内循环来实现这就是冒泡排序
——————————
冒泡排序升序原理
将序列当中的左右元素依次比较 保证右边的元素始终大于左边的元素
第一轮结束后 序列最后一个元素一定是当前序列的最大值
对序列当中剩下的 n-1 个元素再次开始比较
对于长度为 n 的序列 一共需要执行 n-1 轮比较
每轮比较找到最大的数 小的换到左边 大的换到右边 此为冒泡:
——————————
假设有 10 个数
%%%%%
第 1 轮循环
第 1 个数和第 2 个数比较
如果第 1 个数大
第 1 个数和第 2 个数交换位置
否则不动
接着第 2 个数和第 3 个数比较
如果第 2 个数大
第 2 个数和第 3 个数交换位置
否则不动
N 次捉对比较后
第 9 个数和第 10 个数比较
如果第 9 个数大
第 9 个数和第 10 个数交换位置
否则不动
第 1 轮循环结束
最大的数挪到了第 10 个数的位置
比较进行了 9 次
%%%%%
第 2 轮循环
第 1 个数和第 2 个数比较
如果第 1 个数大
第 1 个数和第 2 个数交换位置
否则不动
N 次之后
第 8 个数和第 9 个数比较
如果第 8 个数大
第 8 个数和第 9 个数交换位置
否则不动
第 2 轮循环结束
第 2 大的数挪到了第 9 个数的位置
比较进行了 8 次
%%%%%
第 N 次循环
%%%%%
第 9 轮循环
第 1 个数和第 2 个数比较
如果第 1 个数大
第 1 个数和第 2 个数交换位置
否则不动
第 9 轮循环结束
倒数第 2 大的数挪到了第 2 个数的位置
比较进行了 1 次
这就是冒泡排序实现思路!
——————————
如何实现
主要是通过复用内循环来实现该功能:
for ( int i = 0; i < A.length - 1 ; i ++ ) {
if ( A[i] > A[i + 1] ) {
temp = A[i + 1];
A[i + 1] = A[i];
A[i] = temp;
}
}
这个比较好理解 就是第一轮循环
那么第 2 轮怎么比较呢 其实比较和上轮几乎一样 只不过比较次数比第 1 次少 1 次
第 3 轮怎么比较呢 其实比较和上 轮几乎一样 只不过比较次数比第 2 次少 1 次
以此类推
所以我们要复用内循环 而内循环的次数由 i < 数组长度 - 1 决定
那么 我们要使她每轮循环后递减 不难想到 可以再嵌套循环 将条件改为 i < 数组长度 - 1 - j
j 从零递增 那么第 1 次 内循环执行了 数组长度 - 1 -0 次
第二次 内循环执行了 A.length - 1 -1
N 次之后……
第九次执行了 A.length - 1 - 8 次 A.length = 10
——————————
冒泡优点
冒泡排序的优点是
每进行一趟排序 就会少比较一次 因为每进行一趟排序都会找出一个较大值
也就是说 每进行一趟比较 每一趟少比较一次 一定程度上减少了算法的量
——————————
冒泡测试程序示例
test.java demo && code:
public class test {
public static void main(String[] args) {
int A[] = { 10, 2, 3, 1, 20, 9, 18, 6, 24, 5 };
System.out.print ( "冒泡排序 原数组为 >>> nt" );
for ( int a : A )
System.out.print ( a + " " );
System.out.print ( "nn开始冒泡排序 升序.." );
for ( int i = 0; i < A.length - 1; i ++ ) {
for ( int j = 0; j < A.length - 1 -i; j ++ ) {
if ( A[ j ] > A[j + 1] ) {
int B = A[j];
A[j] = A[j+1];
A[j+1] = B;
}
}
}
System.out.print ( "n冒泡排序后 原数组升序为 >>> nt" );
for ( int a : A )
System.out.print ( a + " " );
System.out.print ( "nn开始冒泡排序 降序.." );
for ( int i = 0; i < A.length - 1; i ++ )
for ( int j = 0; j < A.length - 1 -i; j ++ )
if (A[j] < A[j+1]) {
int B = A[j];
A[j] = A[j+1];
A[j+1] = B;
}
System.out.print ( "n冒泡排序后 原数组降序为 >>> nt" );
for ( int a : A )
System.out.print ( a + " " );
System.out.println ();
}
}



