数组中常用的简单算法

1. 数组元素的赋值（杨辉三角 回型数）
2. 数组元素中的最大值 最小值 平均数 总和等... .. .
3. 数组的复制 反转 查找（线性法查找 二分法查找）
4. 数组元素的排序算法

1

		/*
		 * 1
		 * 1 1
		 * 1 2 1
		 * 1 3 3 1
		 * 1 4 6 4 1
		 * 
		 * --------------------------------------------------
		 * 抽象：二维数组 数组中每个元素数组长度 == 数组元素个数
		 * 算法：二维数组首位元素都是1 从第三行开始 数组元素[i][j] == [i - 1][j - 1] + [i - 1][j];
		 */
		 
		//1. 声明并初始化二维数组
		int[][] yangHui = new int[10][];
		
		//2. 给数组的元素赋值
		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 给每行的非首末元素赋值
			//if(i > 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

		/*
		 *
		 * 算法的考查：求数值型数组中元素的最大值/最小值/总和值/平均值
		 * （数组元素值为两位随机整数）
		 */
		
		// 定义 int 类型一维数组 赋予随机数（两位数 10 ~ 99）
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 90 + 10);
		}
		
		// 遍历数组
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		// 数组元素最大值
		int maxNumber = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > maxNumber) {
				maxNumber = arr[i];
			}
		}
		System.out.println("数组元素最大值：" + maxNumber);
		
		// 数组元素最大值
		int minNumber = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] < minNumber) {
				minNumber = arr[i];
			}
		}
		System.out.println("数组元素最小值：" + minNumber);
		
		// 总和
		int sumNumber = 0;
		for (int i = 0; i < arr.length; i++) {
			sumNumber += arr[i];
		}
		System.out.println("数组元素总和值：" + sumNumber);
		
		// 平均值
		System.out.println("数组元素平均值：" + sumNumber / arr.length);

3

		/*
		 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找) 
		 */
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		int[] arr = new int[]{23,121,12,232,213,21,65,435,83,3,1,345,99};
		// 定义复制数据的数组
		int[] arr1 = new int[arr.length];
		// 遍历复制数据的数组 将 arr1 = arr
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		// 遍历数组 输出复制数据的数组
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i] + " ");
		}
		System.out.println();
		
		
		// 数组的反转
//		// 1. 循环交换前后值 直到 length / 2
//		/*
//		 * 0/length - 1
//		 * 1/length - 1 - 1
//		 * i/length - 1 - i
//		 * ... .. .
//		 * i < length / 2
//		 */
//		
//		// 遍历数组
//		for (int i = 0; i < arr.length / 2; i++) {
//			int temp = arr[i];
//			arr[i] = arr[arr.length - 1 - i];
//			arr[arr.length - 1 - i] = temp;
//		}
//		// 遍历数组
//		for (int i = 0; i < arr.length; i++) {
//			System.out.print(arr[i] + " ");
//		}
//		System.out.println();
		
		// 2. 循环交换前后值 直到 length / 2
		/*
		 * int i j;
		 * i++
		 * j--
		 * i j 交换值
		 * i == 0 ... ++
		 * j == length - 1 ... --
		 * （i j 不能相遇 相遇后就会回转数值 相等就是数值本身）（i < j）
		 */
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		// 遍历数组
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		// 数组的查找
		// 二分法查找
		/*
		 * 二分查找的前提时有序排列
		 * 1. 将数据按照下标值二分（head + end）/2 取中间值
		 * 2. 数据大于中间值 ---> 向右方寻找 ---> head == middle + 1
		 * 3. 数据效域中间值 ---> 向左方寻找 ---> end == middle - 1
		 * 4. 循环二分直到中间值是所需数据
		 */
		
		// 前提条件 数组有序排列
		int[] arr2 = new int[]{5,23,45,62,71,85,96,101,232,453};
		// 定义需要查找的数据
		int searchNumber = 101;
		
		// 初始首索引
		int head = 0;
		// 初始末索引
		int end = arr2.length - 1;
		// 中间值
		int middle = 0; 
		// 搜索成功？失败
		boolean isFlag = false;
		
		while (head <= end) {
			middle = (head + end) / 2; 
			if (searchNumber == arr2[middle]) {
				System.out.println("搜索成功（数据索引） ---> " + middle);
				isFlag = true;
				break;
			} else if (searchNumber < arr2[middle]) {
				end = middle - 1;
			} else if (searchNumber > arr2[middle]) {
				head = middle + 1;
			}
		}
		if (isFlag == false) {
			System.out.println("搜索失败... .. . ");
		}
		
		// 线性查找（地毯式查找）
		// 前提条件 数组有序排列
		int[] arr3 = new int[]{5,23,45,62,71,85,96,101,232,453};
		// 定义需要查找的数据
		int searchNumberTwo = 101000;
		// 搜索成功？失败
		boolean isFlagTwo = false;
				
		for (int i = 0; i < arr3.length; i++) {
			if (arr3[i] == searchNumberTwo) {
				System.out.println("搜索成功（数据索引） ---> " + i);
				isFlagTwo = true;
				break;
			}
		}
		if (isFlagTwo == false) {
			System.out.println("搜索失败... .. . ");
		}

4

		/*
		 * 数组的冒泡排序的实现
		 * 1. 比较轮数（数字 n 的 (n - 1)轮）
		 * 2. 比较次数（每个数字的比较次数是递减的 因为冒泡排序每轮获取前面所有元素的最大值放入后面或者前面）
		 * 0			length - 1 - 0
		 * 1			length - 1 - 1
		 * i			length - 1 - i
		 */
		
		int[] arr = new int[]{23,-34,34,45,-23,343,23,56,-67,67,453,2342,232};
		
		// 比较的轮数
		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] + " ");
		}

数组中常用的简单算法

原文：https://www.cnblogs.com/weinen/p/14589253.html