本文详细介绍了Java中的循环结构，包括while、do-while和for循环，并通过实例展示了如何使用数组和循环处理数据，如计算平均分和解决二重循环问题。此外，还探讨了冒泡排序的原理和实现，包括升序和降序排序的代码示例。内容深入浅出，适合初学者巩固循环和排序知识。
##################################################
目录
##################################################
循环热身
——————————
前言
我们有了 循环加数组 就等于
你强任你强、东皇墨子加张良。。
你骚任你骚、李白韩信加名刀。。
你秀继续秀、亚瑟典韦凯绕后。。
你狂继续狂、玄策阿珂兰陵王。。
肉到干不死？貂蝉吕布老夫子。。
残血追不到？哪吒诸葛元气炮。。
对面距离长？守约干将秦始皇。。
哈哈哈 想不到吧 突如其来的鬼畜。。
咯咯咯咯咯……
突如其来的骚 闪掉崽崽的腰！
哈哈哈哈哈……
不皮了 我们学会了用循环和数组解决问题
还会用循环解决需要重复执行的操作
我们还知道 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序号\t\t\t金额￥" );
for ( int i = 1; i <= M.length; i ++ )
System.out.println ( i + "\t\t\t" + M[i - 1] );
System.out.println ( "\n总金额 >>> "+
( M[0] + M[1] + M[2] + M[3] + M[4]) );
}
}cmd demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>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:\Users\byme\javaTest>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:\Users\byme\javaTest>——————————
利用 for 循环结构计算一组数据的平均分
test.java code：
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in); /* Scanner 输入方式 */
int[] A; /* A[] */
int num = 0, sum = 0; /* 数组长度, 数组总和 */
System.out.print ( "指定该数组长度\n<<< " );
num = input.nextInt();
A = new int[num]; /* 为数组 A 开辟一个长度为 num 的内存空间 */
System.out.printf ( "请输入 %d 个 int <<< ", num ); /* 交互信息 */
for ( int i = 0; i < A.length; sum += A[i], i ++ ) {
/* i < A[] 的长度表示 i 最大为 9 自增之后为 10 则该条件不成立 */
A[i] = input.nextInt(); /* 循环接收数据 储存在数组 A 中 */
System.out.println ( "储存的第 [" + (i + 1) + "] 个数据为 >>> [" + A[i] + "]" );
/* 之后进行累加操作 sum += A[i] 等同于 sum = sum + A[i] 注意迭代部分 必须在 i ++ 之前不然可能数组越界 */
}
System.out.println ( num + " 个数的平均分为 >>> " +
(double) sum / A.length); /* 输出并将该运算公式的结果转换为小数 */
}
}cmd demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>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:\Users\byme\javaTest>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:\Users\byme\javaTest>##################################################
初识二重循环
%%%%%
将此程序升级为二重循环
先用循环解决一个问题
需求：
VIP 添加用户积分
接收一组用户积分
然后计算本组用户平均积分
test.java code && demo：
/* demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>java test
请输入 5 个用户的积分 当前第 1 组
第 1 位用户的积分 <<< 24
第 2 位用户的积分 <<< 45
第 3 位用户的积分 <<< 67
第 4 位用户的积分 <<< 10
第 5 位用户的积分 <<< 8
本组用户平均积分为 >>> 30.8
C:\Users\byme\javaTest>
*/
import java.util.*;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in); /* Scanner 输入方法 */
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]; /* 总和 初始为 0 = 上次和 + 此次 注意 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 + "\t\n") ;
}
}运行结果如下 以下结果都在 calc 程序中验证通过绝对正确 demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>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:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>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:\Users\byme\javaTest>%%%%%
外循环处理数据
这次改成外循环中求平均数 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]; /* 这次单纯累加总和 初始为 0 = 上次和 + 此次 */
}
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:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>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:\Users\byme\javaTest>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:\Users\byme\javaTest>——————————
二重循环规律
现在 我们应该明白一个规律：
外层循环跑一趟
内层循环跑一遍
假如 外层循环 5 次 内层也是 5 次
外层跑 1 趟 内层跑 1 遍 就是外层跑 1 次 内层跑 5 次
当外层跑完 5 趟 循环结束
一共跑了 外层 5 次 内层 5 * 5 = 25 次
是不是很神奇？！##################################################
利用二重循环解决鸡兔同笼问题
——————————
题目
需求：
古代数学家 张丘建 在《算经》中 出了一道 百钱买百鸡 的问题
5 文钱 可以买 1 只公鸡
3 文钱 可以买 1 只母鸡
1 文钱 可以买 3 只雏鸡
现在用 100 文钱买 100 只鸡 那么 公鸡、母鸡、雏鸡 各几只？
在古代这种一题多答的不多
——————————
运行效果
cmd demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>java test
公鸡_4 母鸡_18 雏鸡_78
公鸡_8 母鸡_11 雏鸡_81
公鸡_12 母鸡_4 雏鸡_84
C:\Users\byme\javaTest>——————————
Java 代码
test.java code：
import java.util.Scanner;
public class test {
public static void main(String[] args) {
/* 分析需求 发现 用二重循环可以实现
*
* 首先 公鸡不可能为 0
* 因为就变成了 0:25:75 你敢说这符合题意？
*
* 所以先假设公鸡为 0 然后递增
* 慢慢找出一种推算方法
* (公鸡 + 4) && (母鸡 - 7) && (小鸡 + 3) == 100
*
* 假设 i 表示公鸡 j 表示母鸡 又因为一共 100 文钱
* 则条件为
* i !> 20 j !> 33
*
* 而假设 k 表示雏鸡 这个为 3 的倍数 又因为一共 100 文钱
* 则条件为
* (5 * i) + (3 * j) + (k / 3) = 100
*
* 有因为 一共 100 只鸡
* 则条件为
* i + j + k = 100
*/
int k = 0; /* 雏鸡数 乘于 3 时这里不用 3.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)
)
/* 遍历推算 符合条件的钱数为 100 && 个数为 100 && 都不为 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：
/* demo：
C:\Users\byme\javaTest>javac test.java
C:\Users\byme\javaTest>java test
冒泡排序 原数组为 >>>
10 2 3 1 20 9 18 6 24 5
开始冒泡排序 升序..
冒泡排序后 原数组升序为 >>>
1 2 3 5 6 9 10 18 20 24
开始冒泡排序 降序..
冒泡排序后 原数组降序为 >>>
24 20 18 10 9 6 5 3 2 1
C:\Users\byme\javaTest>
*/
public class test {
public static void main(String[] args) {
int A[] = { 10, 2, 3, 1, 20, 9, 18, 6, 24, 5 }; /* 一组数列 */
/* 遍历原数组 */
System.out.print ( "冒泡排序 原数组为 >>> \n\t" );
for ( int a : A )
System.out.print ( a + " " );
/* 冒泡升序 */
System.out.print ( "\n\n开始冒泡排序 升序.." );
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] ) {
/* 交换值 通过临量 B */
int B = A[j];
A[j] = A[j+1];
A[j+1] = B;
}
}
}
/* 遍历处理之后的数组 */
System.out.print ( "\n冒泡排序后 原数组升序为 >>> \n\t" );
for ( int a : A )
System.out.print ( a + " " );
/* 冒泡降序 其实降序 直接倒着遍历就好 这里使用冒泡实现 为了呈现思路 */
System.out.print ( "\n\n开始冒泡排序 降序.." );
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冒泡排序后 原数组降序为 >>> \n\t" );
for ( int a : A )
System.out.print ( a + " " );
System.out.println ();
}
}
2487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
