java：数组及数组常用算法总结

java：数组常用部分算法的详细总结

一、概念

数组是一种容器，可以储存同一种类型的元素的“容器”;

注意：

数组每一个元素用下标，来表示元素，

​ 下标由0开始，而不是1，

所以：

最后一位元素下标比实际长度小一个数字单位；

二、定义

数据类型 [] 数组名称；

三、数组的初始化

动态初始化：定义数组时，指定数组长度，系统默认自动为数组元素赋初始值

​				格式：数据类型 [] 数组名称 =new 数据类型[数组长度];

静态初始化：直接指定数组元素内容，系统指定数组长度；

​				格式：数据类型 [] 数组名称 =new 数据类型 []{x1,x2,x3........};

​							简写：数据类型 [] 数组名称={x1,x2,x3......}; 

错误写法：

​				数据类型 [] 数组名称 = new 数据类型[数组长度]{x1,x2,x3...};
注意：中括号 [] ,可写在数组名称前后，不会出现语法错误，依照个人习惯即可;

示例代码：

public static void main(String[] args) {
    
		//动态初始化:  定义了数组长度为6的整型数组arr;
		int [] arr=new int[6];
		//静态初始化:  定义了数组长度为3的整型数组arr2;
		int [] arr2=new int[] {1,2,3};
		//静态初始化简写:   定义了直接写入元素1，2，3的整型数组arr3;
		int [] arr3= {1,2,3};		
	}

四、数组的经典算法应用

1、数组遍历

思路：运用for循环依次遍历数组元素，并输出；

public static void main(String[] args) {
		//静态初始化了 一个长度为6的整形数组arr;
		int [] arr= {1,2,3,4,5,6};
		//for循环遍历数组 并显示
		//此处输出代码为了输出美观而写，非必要;
		System.out.print("数组内容:[");
		for(int x=0;x<arr.length;x++) {
			if(arr.length-1==x) {
				System.out.print(arr[x]+"]");
			}else {
				System.out.print(arr[x]+",");
			}
		}
	}

运行结果：

数组内容：[1,2,3,4,5,6]

2、数组中找最大数

思路：

1、假设对比，假设一个最大数；

2、运用for循环依次向后对比每一个数组元素；

3、大于假定数的成为最大值，并输出；

public static void main(String[] args) {
		//静态初始化了 一个长度为6的整形数组arr,找出它的最大数;
		int [] arr= {20,60,52,70,90,4};
		//假定一个最大值max;
		int max=0;
		//for循环依次比较输出
		for(int x=0;x<arr.length;x++) {
			//大于最大值的元素，成为最大值，与下一个元素进行比较
			if(arr[x]>max) {
				max=arr[x];
			}
		}
		System.out.println("最大数为:"+max);		
	}

运行结果：

数组最大数为:90

3、数组元素逆序

思路：对数组进行逆向排序

1、分析可得出中间区间在任何情况一定是不存在或不移动的；

2、所以利用for循环，将数组一分为二对前后对比对称元素

两两交换位置，循环结束，得到结果并输出；

public static void main(String[] args) {
		//静态初始化了 一个长度为6的整形数组arr,对它进行逆向输出;
		int [] arr= {1,2,3,4,5,6};
		System.out.println("逆序排序前的数组:");
		getShow(arr);
		//for循环
		//length/2将数组一分为二
		for(int x=0;x<arr.length/2;x++) {
			//元素交换的中间变量
			    int temp=0;
				temp=arr[x];
				arr[x]=arr[arr.length-1-x];
				arr[arr.length-1-x]=temp;		
		}
		//输出方法
		System.out.println("逆序排序后的数组:");
		getShow(arr);
	
	}
	//遍历输出方法
	public static void getShow(int [] arr) {
		System.out.print("[");
		for(int x=0;x<arr.length;x++) {
			if(arr.length-1==x) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+",");
			}
		}
	}

运行结果：

逆序排序前的数组:
[1,2,3,4,5,6]
逆序排序后的数组:
[6,5,4,3,2,1]

四、数组简单查询

思路：

1、for循环遍历数组，依次对比，if==判断查询元素是否存在于数组；

2、存在返回下标，不存在返回-1；

public static void main(String[] args) {
		//静态初始化了 一个长度为6的整形数组arr,对它进行逆向输出;
		int [] arr= {1,2,3,4,5,6};
		//查找数字5在 数组arr中的位置;
		findArr(arr, 5);	
	}
	
	//元素查找方法  参数为 arr 所要查询的数组，key 查询的数字
	//查找到返回元素下标
	//未查找到返回-1
	public static int findArr(int [] arr,int key) {
		int index=-1;
		for(int x=0;x<arr.length;x++) {
			if(arr[x]==key) {
				System.out.println("所查询的数字在数组下标为 ："+x);
				break;
			}
		}
		return -1;	
	}

运行结果：

所查询的数字在数组下标为 ：4

五、数组二分查找法

二分法前提：数组有序

思路：1、设置一个 数组下标中间值变量mid， 初始值为： （上界-下界）/2的数组下标；

​ 2、设置一个 数组下标上界变量top 初始值为:数组最后一个元素下标；

​ 3、设置一个 数组下标下界变量bottom 初始值为：数组第一个元素下标；

​ 4、for循环，将所查找元素与mid下标数组变量 循环对比；

​ 5、若查找元素大于mid，则mid变量+1，变为bottom，同时mid进行重新计算；

​ 6、若查找元素小于mid，则mid变量-1，变为top，同时mid进行重新计算；

​ 7、对查询结果进行输出；查询不到在输出后提前输出结果;

	public static void main(String[] args) {
		//静态初始化了 一个长度为6的整形数组arr,对它进行逆向输出;
		int [] arr= {1,2,3,4,5,6};
		//查找数字5在 数组arr中的位置;
		findArr(arr, 5);
		
	}
	//二分元素查找法
	//查找到返回下标，提前判断围在数组情况；
	public static void findArr(int [] arr,int key) {
		//定义初始界定变量
		int top=arr.length-1;
		int bottom=0;
		//提前判断所查询数据是否在数组内
		if(key>arr[top]||key<arr[bottom]) {
			System.out.println("所查询数值没有在数组之内");
		}
		//for循环判断查找
		for(int x=0;x<arr.length;x++) {
			//将mid 定义在for循环内部 才能动态改变中间值；
			int mid=(top+bottom)/2;
			//若参数key=中间变量mid,则返回查询结果
			if(key==arr[mid]) {
				System.out.println("已查询到数组元素 "+key+" 的数组下标为："+mid);
				break;
			}
			//若查找元素大于mid，则mid变量+1，变为bottom，同时mid进行重新计算；	
			if(key>arr[mid]) {
			
				bottom=mid+1;
			}
			//若查找元素小于mid，则mid变量-1，变为top，同时mid进行重新计算；
			if(key<arr[mid]){		
				top=mid-1;
			}
		}		
	}

运行结果：

已查询到数组元素 5 的数组下标为：4

六、冒泡排序

思路：

1、比较相邻两个元素，左边元素大于右边元素，则左右交换；

2、每一对相邻元素向后依次这样比较，直到已比较交换出最大元素放置在数组最后一位；

3、遍历数组，再次循环上述步骤，除去上一轮和已经选出的最大元素（随着选出的最大数值愈来愈多，两两比较次数会相应减少）；

public class Test {
		public static void main(String[] args){
		//定义一个数组arr
		int [] arr= {3,5,4,1,2};
		//排序前的数组
		System.out.println("排序前的数组:");
		printShow(arr); 
		
		//外层控制再次重复步骤
		for(int i=0;i<arr.length-1;i++){
			//内层for循环控制 控制数组元素两两比较次数
			for(int j=0;j<arr.length-1-i;j++) {
				if(arr[j]>arr[j+1]) {
					//temp作为中间值 
					//如果前一项大于后一项 则交换位置
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
		}		
	}
		//输出排序后的数组
		System.out.println("排序后的数组：");
		printShow(arr); 
	}
	//遍历数组并显示方法
	public static void printShow(int [] arr) {
				System.out.println("数组如下:");
				System.out.print("[");
				for(int i=0;i<arr.length;i++) {
					if(i==arr.length-1) {
						System.out.print(arr[i]+"]");
					}else {
						System.out.print(arr[i]+",");
					}
				}
				System.out.println("");
	}
}

运行结果：

排序前的数组:
数组如下:
[3,5,4,1,2]
排序后的数组：
数组如下:
[1,2,3,4,5]

结语：数组应用非常广泛，上面总结介绍了数组的部分常用算法，以及数组的定义方式；熟能生巧，大家可以仿照上面实例的代码多加练习；

不是吧，不是吧，！，不会真的有人不点赞吧！。。！！

本文地址：https://blog.csdn.net/qq_43137699/article/details/107579081