数组相关常见算法_Java语言基础

一、简单概述

1)、Java语言基础数组相关的基础算法，面试题里面经常碰到的也有(建议收藏)
2)、10种常见的排序方式，但个人觉得Java开发后端开发了解熟悉4个就行，其他的了解思想就行，全部弄好时间太久，在开发中都是封装好了的，直接调用就行，不会要你去手写。在这里给出冒泡和快排的代码，其他的排序请看相关的算法教程

二、要点概述

二、代码笔记

1.数组元素的赋值

1)、笔记

/*
 * 1.数组元素的赋值
 * 	>这里就只写杨辉三角,如想练习更多的数组赋值，可以百度，有很多题目
 * 	
 * */

2)、代码

public class YangHuiTest01 {
	public static void main(String[] args) {
		//1.首先声明并初始化二维数组
		int[][] yangHui=new int[10][];
		//2.给数组的元素赋值,用for循环
		for (int i = 0; i < yangHui.length; i++) {
			yangHui[i]=new int[i+1];
			//2.1给首末元素赋值
			yangHui[i][0]=yangHui[i][i]=1;
			//2.2给每行的非首末元素赋值,从1开始，到末尾-1
			for(int j = 1;j < yangHui[i].length - 1;j++){
				yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
			}
		}
		//3.遍历二维数组
		for (int i = 0; i < yangHui.length; i++) {
			for (int j = 0; j < yangHui[i].length; j++) {
				System.out.print(yangHui[i][j]+" ");
			}
			System.out.println();
		}
	}
}

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

1)、笔记

/*
 * 2.求数值型数组中元素的最大值、最小值、平均数、总和
 * 	>题目:定义一个int型一维数组，包括10元素，分别赋值一些随机整数，所有随机数都是两位数
 * 	>随机数公式:(Math.random() * (99-10+1)+ 10)
 * 	>[10,99]--->[A,B]
 * */

2)、代码

public class MaxMinSumAvgTest02 {
	public static void main(String[] args) {
		//1.定义一个数组
		int[] arr= new int[10];
		//2.定义10个两位数的随机整数，(int)为强转为int类型
		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.println(arr[i]);
		}
		
		//3.求随机数组的最大值
		int maxValue=arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue<arr[i]) {
				maxValue=arr[i];
			}
		}
		System.out.println("最大值为:"+maxValue);
		
		//4.求随机数组的最小值
		int minValue=arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue>arr[i]) {
				minValue=arr[i];
			}
		}
		System.out.println("最小值为:"+minValue);
		
		//5.求数组元素的总和
		int sum=0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		System.out.println("总和为:"+sum);
		
		//6.求数组的平均值
		int avgValue=sum/arr.length;
		System.out.println("平均值为:"+avgValue);
	}
}

3.数组的复制、反转、查找

1)、笔记

/*
 * 3.数组的复制、反转、查找
 * 	>数组的复制，区别于数组变量的赋值:arr1=arr2,这个在内存中地址值只有一个
 *	>数组反转的方法有很多，都可以在博客上找到
 * 	>折半查找的效率要高很多，但是条件是必须是有序的
 * */

2)、代码

import org.junit.Test;

public class CopyReversalFindTest03 {
	/*
	 * 数组的复制
	 * */
	@Test
	public void copyDemo01(){
		//1.创建一个int数组(什么数组都可以，我这里用int型的数组)
		int[] int1=new int[]{1,3,5,8,7,10,12,88};
		//2.int1数组的长度给到int2
		int[] int2=new int[int1.length];
		//3.利用for循环把int1中数组的元素赋值给到int2
		for(int i=0;i<int2.length;i++){
			int2[i]=int1[i];
		}
		//4.遍历验证是否成功复制
		for (int i = 0; i < int2.length; i++) {
			System.out.println(int2[i]);
		}
	}
	
	/*
	 * 数组的反转
	 * */
	@Test
	public void reversalDemo02(){
		//1.创建一个int数组
		int[] int1=new int[]{1,3,5,8,7,10,12,88};
		//2.数组反转的方法(这里只写一种)
		for(int i=0;i<int1.length/2;i++){
			int temp= int1[i];
			int1[i]=int1[int1.length-i-1];
			int1[int1.length-i-1]=temp;
		}
		//3.验证遍历
		for (int i = 0; i < int1.length; i++) {
			System.out.println(int1[i]);
		}
	}
	
	/*
	 * 数组的查找:线性查找和折半查找(也叫二分法查找)
	 * 
	 * */
	//线性查找
	@Test
	public void findDemo03(){
		//1.创建一个int数组
		int[] int1=new int[]{1,3,5,8,7,10,12,88};
		int dest=12;
		//2.定义一个isFlag变量，如果没有找到输出相应的要求
		boolean isFlag=true;
		//3.查找逻辑
		for(int i=0;i<int1.length;i++){
			if (dest==(int1[i])) {
				System.out.println("找到/位置为:"+i);
				isFlag=false;
				break;
			}
		}
		if (isFlag) {
			System.out.println("没有这个元素。");
		}
	}
	
	//折半查找,必须有序，不管是升序还是降序
	@Test
	public void findDemo04(){
		//1.创建一个int数组
		int[] int1=new int[]{-8,-7,-2,1,3,5,8,7,10,12,88};
		//2.设置查找的数
		int dest=-2;
		//3.初始化的首索引
		int head=0;
		//4.初始化的末索引
		int end=int1.length-1;
		//5.定义一个isFlag变量，如果没有找到输出相应的要求
		boolean isFlag=true;
		//6.查找逻辑
		while(head<=end){
			int middle=(head+end)/2;
			if(dest==int1[middle]){
				System.out.println("找到/位置是:"+middle);
				isFlag=false;
				break;
			}else if(int1[middle]>dest){
				end=middle-1;
			}else{
				head=middle+1;
			}
		}
		if (isFlag) {
			System.out.println("没有找到。");
		}
	}
}

4.数组元素的排序算法

1)、冒泡排序代码

/*
 * 4.冒泡排序
 * 
 * */
public class BubbleSortTest04 {
	public static void main(String[] args) {
		//1.定义一个int型数组(其他的类型的也行)
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99,-88,100};
			//2.冒泡逻辑
			for(int i = 0;i < arr.length - 1;i++){
				for(int j = 0;j < arr.length - 1 - i;j++){
					//2.1数组从小到大排序
					if(arr[j] > arr[j + 1]){
						int temp = arr[j];
						arr[j] = arr[j + 1];
						arr[j + 1] = temp;
					}
				}
			}
			//3.输出排序好的数组
			for(int i = 0;i < arr.length;i++){
				System.out.println(arr[i]);
			}
		}
}

2)、快速排序代码

/*
 * 5.快速排序
 * 
 * */
public class QuickSortTest05 {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

三、最后

1.给到初级程序员的建议:数组这里最主要的是相关的知识点，一定掌握牢固，至于数组的相关算法的排序就是一个知识的拓展，需要手写的，在面试中遇见的几率比较大，已经列出代码，其他的就是理解他的思想就行，在谈及时，最起码知道有这么一个东西，然后知道思想是怎么实现的，可能10Java后端开发程序员中，9个是不会把精力放在上面的(初中级)
2.花费的时间应该在相关基础知识点上，而不是算法这种东西，要去面试的时候，抽时间重新看一下，能手写出要手写的，了解其他的排序思想就行