Java自学笔记 （数组-数组常见算法）

最新推荐文章于 2024-02-19 19:09:16 发布
最新推荐文章于 2024-02-19 19:09:16 发布
阅读量229 收藏
点赞数 1
分类专栏： Java 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s17183882569/article/details/119257701
版权
本文介绍了如何通过Java实现数组的常见操作，包括杨辉三角的计算、数值数组的基本统计、复制反转查找、排序算法（如冒泡排序）等。还涉及了数组元素赋值、数组复制与查找的不同方法，以及求解数组元素最大值、最小值、平均数和总和的实例。
摘要由CSDN通过智能技术生成

3.4 数组常见算法：

  1. 数组元素的赋值(杨辉三角、回形数等)

  2. 求数值型数组中元素的最大值、最小值、平均数、总和等

  3. 数组的复制、反转、查找(线性查找、二分法查找)

  4. 数组元素的排序算法

1 杨辉三角：
image-20210730232646015
代码示例：

public class ArrayExer1 {
	public static void main(String[] args) {
		
		// 1.声明并初始化二维数组
		int[][] arr = new int[10][];
		
		// 2.给数组元素赋值
		for(int i = 0;i < arr.length;i++) {
			arr[i] = new int[i + 1];
			// 2.1 给首末元素赋值
			arr[i][0] = arr[i][i] = 1;
			// 2.2 给每行的非首末元素赋值
			if(i > 1) {
				for(int j = 1;j < arr[i].length - 1;j++) {
					arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
				}
			}
		}
		
		// 3.遍历二维数组
		for(int i = 0;i < arr.length;i++) {
			for(int j = 0;j < arr[i].length;j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		
	}
}
  1. 求数值型数组中元素的最大值、最小值、平均数、总和等
/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。	
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 */
public class ArrayExer2 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		//求数组元素的总和
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

结果：

25	15	23	19	26	50	96	98	39	74	
最大值为：98
最小值为：15
总和为：465
平均数为：46
  1. 数组的复制、反转、查找(线性查找、二分法查找)
// 3. 数组的复制、反转、查找(线性查找、二分法查找)

public class ArrayTest1 {
	public static void main(String[] args) {
		String[] arr = new String[] {"wuwuwu","yingyingying","jijiji","hahaha"};
		
		// 数组的复制
		// 定义String型数组arr1,并将arr数组元素长度赋给数组arr1(使arr1数组元素长度和arr数组元素长度相等)
		String[] arr1 = new String[arr.length]; 
		for(int i = 0;i < arr1.length;i++) {
			arr1[i] = arr[i];
		//	System.out.print(arr1[i] + " ");
		}
		
	
		// 数组的反转
		// 方式一：
		for(int i = 0;i < arr.length / 2;i++) {
			String temp = arr[i]; // temp：临时变量
			arr[i]= arr[arr.length - i -1];
			arr[arr.length - i -1] = temp; 		
		}
		// 方式二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--) {
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	
		
		// 遍历
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		
		
		// 查找（或搜索）
		// 1.线性查找
		String dest = "hahaha";
		boolean isFlag = true;
		for(int i = 0;i < arr.length;i++) {
			if(dest.equals(arr[i])) {
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if(isFlag) {
			System.out.println("很遗憾，没有找到哦！");
		}
	
		// 二分法查找：
		// 前提：所要查找的数组必须有序
		int[] arr2 = new int[] {-98,-34,2,34,53,66,79,105,210,333};
		
		int dest1 = -34;
		int head = 0; // 初始的首索引
		int end = arr2.length - 1; // 初始的末索引
		boolean isFlag1 = true;
		while(head <= end) {
			int middle = (head + end)/2;
			if(dest1 == arr2[middle]) {
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1) {
				end = middle - 1;
			}else {
				end = middle + 1;
			}
		}
		if(isFlag1) {
			System.out.println("很遗憾，没有找到哦！");
		}
		
		
	}
}

练习：使用简单数组

(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。

(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。

(3)显示array1的内容。

(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引

(如array[0]=0,array[2]=2)。打印出array1

思考：array1和array2是什么关系？ array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体

拓展：修改题目，实现array2对array1数组的复

代码示例：

public class ArrayExer3 {
	public static void main(String[] args) {
		
		// 1. 声明两个int型数组
		int[] array1,array2;
		
        // 2.把array1初始化为8个素数：2,3,5,7,11,13,17,19。
		array1 = new int[] {2,3,5,7,11,13,17,19};
		
        // 3.显示array1的内容。
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		
        // 4.赋值array2变量等于array1
		// 不能称作数组的复制
		array2 = array1; // 将 array1 的地址值赋给了 array2
		// 修改array2中的偶索引元素，使其等于索引 (如array[0]=0,array[2]=2)
		for(int i = 0;i < array2.length;i++) {
			if(i % 2 == 0) {
				array2[i] = i;
			}
		}
		System.out.println();
		// 打印出array1
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		
				
	}
}

拓展：修改题目，实现array2对array1数组的复制

ublic class ArrayExer4 {
	public static void main(String[] args) {
		
		// 1. 声明两个int型数组
		int[] array1,array2;
		// 2.把array1初始化为8个素数：2,3,5,7,11,13,17,19。
		array1 = new int[] {2,3,5,7,11,13,17,19};
		// 3.显示array1的内容。
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		// 4.赋值array2变量等于array1
		// 数组的复制
		array2 = new int[array1.length];
		for(int i = 0;i < array2.length;i++) {
			array2[i] = array1[i];
		}
		// 修改array2中的偶索引元素，使其等于索引 (如array[0]=0,array[2]=2)
		for(int i = 0;i < array2.length;i++) {
			if(i % 2 == 0) {
				array2[i] = i;
			}
		}
		System.out.println();
		// 打印出array1
		for(int i = 0;i < array1.length;i++) {
			System.out.print(array1[i] + " ");
		}
		
	}
}
  1. 数组元素的排序算法：
  • 算法的特征：
输入（Input）有0个或多个输入数据，这些输入必须有清楚的描述和定义
输出（Output）至少有1个或多个输出结果，不可以没有输出结果
有穷性（有限性，Finiteness）算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤
可以在可接受的时间内完成
确定性（明确性，Definiteness）算法中的每一步都有确定的含义，不会出现二义性
可行性（有效性，Effectiveness）算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案
  • 十大内部排序算法：
  1. 选择排序：直接选择排序、堆排序🔺
  2. 交换排序： 冒泡排序🔺、快速排序🔺
  3. 插入排序： 直接插入排序、折半插入排序、Shell排序
  4. 归并排序🔺
  5. 桶式排序
  6. 基数排序
  • 数组的冒泡排序的实现：

介绍：

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

排序思想：

  1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。

  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

代码示例：

public class ArrayTest2 {
	public static void main(String[] args) {
		int[] arr = new int[] {11,45,65,12,89,102,37,85};
		// 冒泡排序
		for(int i = 0;i < arr.length - 1;i++) {
			for(int j = 0;j < arr.length - 1 - i;j++) {
				if(arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j + 1] = temp;
				} 
			}
		}
		// 遍历
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + " ");
		}
		
		
	}
}
唔信哦
关注
专栏目录
Java—数组中涉及的常见算法
小贺想改变
09-04 766
数组元素的赋值(杨辉三角、回形数等)，求数值型数组中元素的最大值、最小值、平均数、总和等，数组的复制、反转、查找(线性查找、二分法查找)，数组元素的排序算法
06-数组-自己使用的C语言教程PPT-适合老师备课或者自学.pptx
11-07
在学习C语言时，数组是一种非常基础且重要的数据结构。本篇教程主要讲解了关于一维数组的定义、引用以及相关的编程...通过深入学习和实践，可以熟练掌握数组的使用，为后续学习更高级的数据结构和算法打下坚实的基础。
Java面试干货：关于数组查找的几个常用实现算法
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
11-16 2269
假如要查找的元素在前半段，那么继续按照斐波那契数列来看，55 = 34 + 21，所以继续把前半段分成前34个数据元素的前半段和后21个元素的后半段，继续查找，如此反复，直到查找成功或失败。斐波那契查找也叫做黄金分割法查找，这种查找法其实也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。5.最后，又将mid所指向的元素(19)与待查找元素(19)进行比较，结果相等，则查找成功，返回mid指针指向的元素的位序。从折半查找中可以看出，折半查找的查找效率还是不错的。
Java 数组算法
m0_54845475的博客
08-05 217
比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个，即需要进行 length-1 次。第一次是对 n 个数进行 n-1 次比较，进行到最后第 n 个的一个是最大的；第二次是对 n-1 个数进行 n-2 次比较，进行到最后第 n-1 个的一个是最大的；… 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。......
Java数组常见算法
Sky529353的博客
04-04 1186
1.定义方法: int [] a = new int[10]; int [] b = new int[]{1,2,3,4,5};//动态初始化 int [] c = {1,2,3,4,5};//静态初始化 2.数组相关算法： 2.1冒泡排序 每次遍历，如果前一位大于后一位的话，就将前一位大的数字向后移动。最终实现将数组从小到大依次排序。 int [] c = {1,2,3,4,5,6,7,33,44,11,7,99,88}; int temp; for
【八】Java数组的常见算法
chang_jx的博客
01-20 615
​ 即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。​ 如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。​ 然后比较第2个和第3个元素，将小数放到前面，大数放到后面。在上述的基础上用index时刻记录目前比对的最大/小的下标。思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。（2）然后用max/min与后面的元素一一比。比较两个相邻的元素，将值大的元素交换至右端。（2）遍历数组，看哪些元素和最大值是一样的。（1）先假设第一个元素最大/最小。数组对称位置的元素互换。
Java自学--基础笔记
07-19
学习Java过程记录笔记
java-核心类库-集合框架自学笔记.pdf
11-28
java-核心类库-集合框架自学笔记.pdf
javase基础自学笔记-java开端-概述
最新发布
05-07
本自学笔记将带你初识Java，从概述开始，逐步深入理解这个强大的编程工具。 首先，让我们从"Java开端-概述"入手。Java是一种面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）在1995年发布。它的设计...
Java自学笔记 - 超有用
07-11
【Java自学笔记】 Java是一种广泛使用的面向对象编程语言，其设计思想主要基于对象、类、继承、封装和消息传递等核心概念。面向对象编程（OOP）旨在通过模拟现实世界中的实体来构建软件系统，使得代码更加易于理解...
Java数组的经典算法和应用
11-17
//找出最小值 并把位置给找出来 int minindex=0; //定义minindex并赋初值用于保存最小值的下标 int min; //定义min用于保存最小值 min=a[0]; //数组的第一个数设为最小值 for(i=1;i<7;i++) //因为min=[0]，所以i从1开始 { if(a[i]<min) //如果有比min小的数，就将这个数赋值给min { min=a[i]; minindex=i;//记录下标 } } minindex++; System.out.println("最小值为："+min); System.out.println("最小值是数组中的第"+minindex+"个数"); //输出七个数中的最大值 int maxindex=0; //定义变量minindex并赋初值用于保存最大值的下标 int max; //定义max并赋初值为0，设做是当前最大值，用于存储最大值 max=a[0]; //数组的第一个数设为最大值 for(i=0;i<7;i++) //因为max=a[0]，所以从1开始 { if(max<a[i]) //如果有max大的数，就将这数赋值给max { max=a[i]; maxindex=i; //记录下标 } } maxindex++; System.out.println("最大值为："+max); System.out.println("最大值为数值中的第"+maxindex+"个数。"); //排序使用双重循环 冒泡排序，从小到大派寻 for(i=1;i<7;i++) { for(j=0;j<7-1;j++) { if(a[j]>a[j+1]) { int temp;//临时变量 temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } System.out.print("按从小到大排序："); for(i=0;i<7;i++) System.out.print(" "+a[i]); System.out.println(); //排序使用双重循环 冒泡循环 从大到小排序 for(i=1;i<7;i++) { for(j=0;j<7-i;j++) { if(a[j]<a[j+1]) { int temp; //临时变量 temp=a[j];
几种简单数组公式的用法（入门者必看）
08-02
公式内红色的数字代表要计算的指定的某天的星期序列数，０至６分别代表周日、周一至周六。（本例是计算指定月份内周六的天数）......
Java中数组常见的算法
2302_78070106的博客
02-19 220
Fisher-Yates乱序算法。
Java算法常见面试题及答案
java364100的博客
07-12 8977
随着疫情的好转，各大企业公司纷纷开始复工，招聘也将迎来一个高峰。Java程序员想要在这次疫情后，拿到满意的offer，就必须做好充足的准备。众所周知，算法可以说是大厂面试Java程序员的必问面试题。相信算法的重要性大家都了解，好的算法可以让性能得到万倍提升，做到毫秒级处理千万数据的程度。因此，为了提升大家在面试中的底气，本文整理了一些Java程序员算法面试题并比附上了答案，一起来看看吧！ Java算法常见面试题及答案1、算法的时间复杂度时候是什么？答案：算法的时间复杂度表示程序运行完成所需的总时间，它通常用
java数组的算法_java之数组的常用算法汇总
weixin_42350314的博客
02-20 467
下面给定算法如：1.给定两个数组a{2,3,4,5} b{7,8,9,10 }将两个数组内的元素对应位置互换解答：2.给定一个数组a{1,2,3,4,5,6}将这个数组中的元素头尾对应互换位置int[] array = {1,2,3,4,5,6};System.out.println(array.length / 2)// 等于3for (int i = 0; i < array.len...
java 算法 数组_java算法：数组
weixin_28726871的博客
02-20 99
java算法：数组数组是最基本的数据结构。在java和大多数编程语言中都被定义为简单类型。数组的使用是开发有效算法的基础。数组是相同类型数据的固定集合，它是连续存储的，通过下标来访问数组元素。由于它是与计算机的内存系统直接通讯，可以看成是最基本的数据结构。例一：埃拉托色尼筛，打印出小于给定N的所有素数。Java代码 publicclassPrimes{publicstaticvoidmain(S...
java数组算法题
qq_38815856的博客
03-11 942
1.给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 输入[0,0,1,1,1,2,2,3,3,4], 函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。 思路解析：利用slow=0，fast=1，分别指...
Java 数组 常见算法
LiuNengPython的博客
05-05 852
一、数组元素的赋值（杨辉三角、回形数）//面试中考察较多 //笔试中考察较多 （1）杨辉三角形：以输出前10行为例 二、求数值型数组元素中的最大值、最小值、平均数、总和等等 三、数组的赋值、反转、查找（线性查找、二分法查找） 四、数组元素的排序算法//面试中考察较多 //笔试中考察较多 ...
Java数组之常见算法
m0_56084296的博客
04-22 285
1.数组的创建与元素赋值： 杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。 2.针对于数值型的数组： 最大值、最小值、总和、平均数等 3.数组的赋值与复制 int[] array1,array2; array1 = new int[]{1,2,3,4}; 3.1 赋值： array2 = array1; 如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。 3.2 复制： array2 = ne
Java程序设计自学：数组详解
"Java程序设计自学指导体系文档涵盖了Java编程中的声明和访问控制，特别是关于数组的使用。文档强调了Java数组与C/C++的区别，指出Java不支持直接通过指针访问元素，从而减少错误的可能性。数组是Java中用于存储同...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值