栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

6.1

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

6.1

##################################################

目录

循环热身

前言

三种循环

数组循环接收数据并使用 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 ();
	}
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950507.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号