• 56171

    文章

  • 559

    评论

  • 47

    友链

  • 最近新加了换肤功能,大家多来逛逛吧~~~~
  • 喜欢这个网站的朋友可以加一下QQ群,我们一起交流技术。

数组操作相关算法

695856371Web网页设计师②群 | 喜欢本站的朋友可以收藏本站,或者加入我们大家一起来交流技术!

欢迎来到梁钟霖个人博客网站。本个人博客网站提供最新的站长新闻,各种互联网资讯。 还提供个人博客模板,最新最全的java教程,java面试题。在此我将尽我最大所能将此个人博客网站做的最好! 谢谢大家,愿大家一起进步!

/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
*/
class Test11_FindMax{
	public static void main(String[] args){
		int[] array = {4,2,6,8,1};
		
		//在数组中找最大值
		//类似于:猴子掰玉米
		//先假设第一个最大,然后与后面的元素一一比较,如果有比手上还大,就修改手上的玉米
		
		//(1)//先假设第一个元素最大
		int max = array[0];
		//(2)用max中的值,与后面的元素一一比较,如果有比max的值还大,就修改max的值
		//这里i=1的原因,max与[1,长度-1]的元素比较就可以了,不用再与[0]元素进行比较
		for(int i=1; i<array.length; i++){
			if(array[i] > max){
				max = array[i];
			}
		}
		
		System.out.println("最大值是:" + max);
	}
}
/*
数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
*/
class Test13_SumAndAvg{
	public static void main(String[] args){
		/*
		有一组学员的成绩存储在数组中,统计总分和平均分
		*/
		int[] scores = {78,89,56,99,100};
		
		//求总分
		int sum = 0;
		for(int i=0; i<scores.length; i++){
			sum += scores[i];
		}
		
		//求平均值
		double avg = (double)sum / scores.length;
		System.out.println("总分:" + sum);
		System.out.println("人数:" + scores.length);
		System.out.println("平均分:" + avg);
		
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse{
	public static void main(String[] args){
		//有一个数组,存储26个字母
		//'A'~'Z'
		char[] letters = new char[26];
		for(int i=0; i<letters.length; i++){
			letters[i] = (char)('A' + i);
		}
		
		//需求:要反转整个数组
		//原来letters[0]中存储的是'A'-->现在letters[0]中存储的是'Z'
		//...
		//原来letters[25]中存储的是'Z'-->现在letters[25]中存储的是'A'
		//方式一:定义一个与原来的数组长度相同的新数组,并且逆序复制元素
		char[] newLetters = new char[letters.length];
		//逆序复制元素
		for(int i=0; i<newLetters.length; i++){
			newLetters[i] = letters[letters.length-1-i];
		}
		
		//让letters这个数组名指向新的数组
		letters = newLetters;
		
		//显示结果
		for(int i=0; i<letters.length; i++){
			System.out.println(letters[i]);
		}
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse_2{
	public static void main(String[] args){
		//有一个数组,存储26个字母
		//'A'~'Z'
		char[] letters = new char[26];
		for(int i=0; i<letters.length; i++){
			letters[i] = (char)('A' + i);
		}
		
		//需求:要反转整个数组
		//原来letters[0]中存储的是'A'-->现在letters[0]中存储的是'Z'
		//...
		//原来letters[25]中存储的是'Z'-->现在letters[25]中存储的是'A'
		//方式二:首尾交换
		//问题1:交换几次   次数 = 长度/2  例如:6个元素交换3次,5个元素交换2次
		/*
		这个i可以用作下标,同时循环的次数,可以表示交换的次数
		*/
		for(int i=0; i<letters.length/2; i++){
			//问题2:谁和谁交换
			//letters[0] ~ letters[25]
			//letters[1] ~ letters[24]
			//..
			//首尾交换
			//letters[i] ~ letters[长度-1 - i]
			
			//问题3:如何交换
			//借助第三个变量
			char temp = letters[i];
			letters[i] = letters[letters.length-1-i];
			letters[letters.length-1-i] = temp;
		}
		
		//显示结果
		for(int i=0; i<letters.length; i++){
			System.out.println(letters[i]);
		}
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
	例如:从原数组中截取一部分
(3)复制一个比原来的长的
	例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_01{
	public static void main(String[] args){
		//(1)复制一个和原来一样的数组,长度和元素
		int[] arr = {1,2,3,4,5};
		
		/*
		(1)创建一个新数组,和原来的数组一样
		*/
		int[] newArr = new int[arr.length];
		/*
		(2)复制元素
		*/
		for(int i=0; i<newArr.length; i++){
			newArr[i] = arr[i];
		}
		
		//(3)遍历新数组
		for(int i=0; i<newArr.length; i++){
			System.out.println(newArr[i]);
		}
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
	例如:从原数组中截取一部分
(3)复制一个比原来的长的
	例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_02{
	public static void main(String[] args){
		//(1)复制一个比原来数组短的
		int[] arr = {1,2,3,4,5,6,7,8,9,10};
		
		//复制原来的数组的一部分,来构成新数组,例如:[2]~[8]
		int start = 2;
		int end = 8;
		/*
		(1)创建新数组,新数组的长度 = 8-2
		*/
		int[] newArr = new int[end-start+1];
		
		//(2)复制元素
		for(int i=0; i<newArr.length; i++){
			/*
			newArr[0] = arr[2] = arr[start+0];
			newArr[1] = arr[3] = arr[start+1];
			...
			*/
			//newArr[i] = 值;
			newArr[i] = arr[start+i];
		}
		
		//(3)遍历结果
		for(int i=0; i<newArr.length; i++){
			System.out.println(newArr[i]);
		}
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
	例如:从原数组中截取一部分
(3)复制一个比原来的长的
	例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_03{
	public static void main(String[] args){
		//(3)复制一个比原来的长的
		int[] arr = {1,2,3,4,5};
		
		//需求:新增加了几个数据,需要存储,此时需要把数组进行扩容
		//(1)创建一个新数组,例如:新数组的长度为原来的2倍
		int[] newArr = new int[arr.length*2];
		
		//(2)复制元素
		for(int i=0; i<arr.length; i++){
			newArr[i] = arr[i];
		}
		
		//(3)遍历结果
		for(int i=0; i<newArr.length; i++){
			System.out.println(newArr[i]);
		}
	}
}
/*
程序:
(1)数据结构:如何存储数据
(2)算法:实现功能的代码的逻辑结构

数组的相关的算法操作:
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
(1)复制一个和原来一样的数组,长度和元素
(2)复制一个比原来数组短的
	例如:从原数组中截取一部分
(3)复制一个比原来的长的
	例如:数组扩容,那么新数组会比原来的数组长
*/
class Test15_Copy_04{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5};
		
		/*
		复制一个新数组,新数组的长度由键盘输入,可能和原来一样,可能比原来的短,可能比原来的长
		*/
		/*
		(1)从键盘输入新数组的长度
		*/
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入新数组的长度:");
		int len = input.nextInt();
		
		//(2)创建新数组
		int[] newArr = new int[len];
		
		//(3)复制元素,这里都是从原数组的[0]开始复制
		//i<arr.length && i<newArr.length保证newArr[i] = arr[i];左右两边都不越界
		for(int i=0; i<arr.length && i<newArr.length; i++){
			newArr[i] = arr[i];
		}
		
		//(4)遍历结果
		for(int i=0; i<newArr.length; i++){
			System.out.println(newArr[i]);
		}
	}
}

/*
数组的算法:
1、找最值
2、找最值及其下标
3、统计:累加和、平均值等
4、反转
5、复制
6、查找:在数组中,查找某个值是否存在,或者查找某个值的下标
(1)数组中的元素是无序的
	顺序查找
(2)数组中的元素是有序的
*/
class Test02_Find{
	public static void main(String[] args){
		int[] arr = {1,4,5,7,9};
		
		//在arr的数组中,查找2的下标,或者判断2在数组中是否存在
		int value = 2;
		int index = -1;//因为正常的下标,没有-1
		for(int i=0; i<arr.length; i++){
			if(arr[i] == value){
				index = i;
				break;
			}
		}
		if(index == -1){
			System.out.println(value+"不存在");
		}else{
			System.out.println(value+"在数组中的下标是:" + index);
		}
		
	}
}
/*
数组的算法:
1、找最值
2、找最值及其下标
3、统计:累加和、平均值等
4、反转
5、复制
6、查找:在数组中,查找某个值是否存在,或者查找某个值的下标
(1)数组中的元素是无序的
	顺序查找
(2)数组中的元素是有序的
	①顺序查找
	②二分查找
*/
class Test02_Find_2{
	public static void main(String[] args){
		int[] arr = {1,2,5,7,9,10};//有序的,从小到大
		
		int value = 10;
		
		int index = -1;
		int left = 0;
		int right = arr.length-1;
		int mid = (left + right)/2;
		/*
		假设数组的长度是5,left=0,right=4,mid = 2
		假设数组的长度是6,left=0,right=5,mid = 2
		*/
		
		while(left<=right){
			if(arr[mid] == value){//找到了
				index = mid;
				break;
			}else if(value > arr[mid]){//去右边找
				left = mid + 1;//因为mid比较过了,就不用看了,从mid的下一个作为左边界
			}else{//说明value < arr[mid] 去左边找
				right = mid - 1;
			}
			mid = (left + right)/2;//重新计算mid,因为left或right修改了
		}
		
		if(index == -1){
			System.out.println(value+"不存在");
		}else{
			System.out.println(value+"在数组中的下标是:" + index);
		}
	}
}
/*
数组的算法:
1、找最值
2、找最值及其下标
3、统计:累加和、平均值等
4、反转
5、复制
6、查找:在数组中,查找某个值是否存在,或者查找某个值的下标
(1)数组中的元素是无序的
	顺序查找
(2)数组中的元素是有序的
	①顺序查找
	②二分查找
7、数组的排序
(1)冒泡排序
(2)直接选择排序
*/
class Test03_BubbleSort{
	public static void main(String[] args){
		int[] arr = {4,2,1,8,3};
		
		//希望数组最终是{1,2,3,4,8}或{8,4,3,2,1}
		//现在要实现从小到大
		/*
		冒泡排序:通过相邻元素比较,如果相邻元素的顺序不符合要求,那么就交换。
				 经过几轮之后,实现最终的排序。每一轮都会有一个已经到达正确位置的元素退出比较。
				 
		第一轮:
			第1次:arr[0]和arr[1]比较,4和2比较,不符合要求,交换,{2,4,1,8,3}
			第2次:arr[1]和arr[2]比较,4和1比较,不符合要求,交换,{2,1,4,8,3}
			第3次:arr[2]和arr[3]比较,4和8比较,符合要求
			第4次:arr[3]和arr[4]比较,8和3比较,不符合要求,交换,{2,1,4,3,8}
		
		第一轮之后,最大的,沉到底,跑到最右边
		
		第二轮:
			第1次:arr[0]和arr[1]比较,2和1比较,不符合要求,交换,{1,2,4,3,8}
			第2次:arr[1]和arr[2]比较,2和4比较,符合要求
			第3次:arr[2]和arr[3]比较,4和3比较,不符合要求,交换,{1,2,3,4,8}
		
		第二轮之后,次大的到达正确位置
		
		第三轮:
			第1次:arr[0]和arr[1]比较,1和2比较,符合要求
			第2次:arr[1]和arr[2]比较,2和3比较,符合要求
			
		第四轮:
			第1次:arr[0]和arr[1]比较,1和2比较,符合要求
			
		轮数 = 数组的长度 - 1; //因为每一轮只能确定一个
		*/
		//轮数
		for(int i=1; i<arr.length; i++){//循环次数 = 长度 -1,控制轮数
			/*
			例如:5个元素
			每一轮的次数 = 长度 - i;
			第1轮:4次
			第2轮:3次
			第3轮:2次
			第4轮:1次
			
			第1轮:arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]、arr[3]和arr[4]
			第2轮:arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]
			第3轮:arr[0]与arr[1]、arr[1]和arr[2]
			第4轮:arr[0]与arr[1]
			
			相邻元素:arr[j] 与 arr[j+1]
			第1轮:j的值 :0,1,2,3  j<4		j<5-1	j<5-i
			第2轮:j的值 :0,1,2	j<3		j<5-2
			第3轮:j的值 :0,1		j<2		j<5-3
			第4轮:j的值 :0		j<1		j<5-4
			*/
			for(int j=0; j<5-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] + " ");
		}
	}
}
/*
数组的算法:
1、找最值
2、找最值及其下标
3、统计:累加和、平均值等
4、反转
5、复制
6、查找:在数组中,查找某个值是否存在,或者查找某个值的下标
(1)数组中的元素是无序的
	顺序查找
(2)数组中的元素是有序的
	①顺序查找
	②二分查找
7、数组的排序
(1)冒泡排序
(2)直接选择排序
*/
class Test04_SelectSort{
	public static void main(String[] args){
		int[] arr = {4,2,1,8,3};
		
		/*
		直接选择排序:
			经过很多轮
			每一轮,把当前“未排序”的元素中最大/最小的元素及其位置找出来,
			然后与这“最大/最小”值本来/正确的位置的元素进行交换
		也可以理解为直接插入排序
		
		以从小到大为例
		第一轮:
			找出本轮最小的值:1,它的下标[2]
			这个最小值,应该在[0]位置,就交换[2]和[0]位置的元素
			{1,2,4,8,3}
		第二轮:
			找出本轮未排序元素中最小的值:2,它的下标[1]
			这个最小值,应该在[1]位置,就可以不动
		第三轮:
			找出本轮未排序元素中最小的值:3,它的下标[4]
			这个最小值,应该在[2]位置,就交换[4]和[2]位置的元素
			{1,2,3,8,4}
		第四轮:
			找出本轮未排序元素中最小的值:4,它的下标[4]
			这个最小值,应该在[3]位置,就交换[4]和[3]位置的元素
			{1,2,3,4,8}
			
		轮数:长度-1
		*/
		for(int i=0; i<arr.length-1; i++){//总轮数 = 长度-1
			//(1)找出本轮未排序元素中的最小值及其下标
			/*
			第1轮:[0]~[4]范围内最小值及其下标
			第2轮:[1]~[4]范围内最小值及其下标
			第3轮:[2]~[4]范围内最小值及其下标
			第4轮:[3]~[4]范围内最小值及其下标
			
			思路:假设本轮未排序的第一个元素最小,然后用min与本轮后面的元素一一比较
			*/
			int min = arr[i];
			int index = i;
			for(int j = i+1; j<arr.length; j++){
				if(arr[j] < min){
					min = arr[j];
					index = j;
				}
			}
			
			//(2)看这个最小值是否在它应该在的位置
			/*
			第1轮:最小值应该在[0]
			第2轮:最小值应该在[1]
			第3轮:最小值应该在[2]
			第4轮:最小值应该在[3]
			*/
			if(index != i){//交换arr[i]和arr[index]
				int temp = arr[i];
				arr[i] = arr[index];
				arr[index] = temp;
			}
		}
		
		//显示结果
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i] + " ");
		}
	}
}

 


 转载至链接:https://my.oschina.net/architectliuyuanyuan/blog/3062597。


转载原创文章请注明出处,转载至: 梁钟霖个人博客www.liangzl.com

0条评论

Loading...


发表评论

电子邮件地址不会被公开。 必填项已用*标注

自定义皮肤
注册梁钟霖个人博客