数组中涉及的常见算法

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

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

eg;定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值、最小值、和、平均值，并输出出来。要求：所有随机数都是两位数

/*定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值、最小值、和、平均值，并输出出来。
要求：所有随机数都是两位数 [10,99] Math.random()*(99 - 10 + 1) + 10
*/
package com.lxy.exer;

public class ArratTest_Max_Min_Sum_Avag {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i = 0; i < arr.length; i++){
			arr[i] = (int)(Math.random()*90 + 10);
			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);
		// 求数组元素平均数
		System.out.println("平均数为：" + sum/arr.length);
		
	}

}

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

eg：//使用简单数组
//（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。

//使用简单数组
//（1）创建一个名为ArrayTest_Copy_Find的类，在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数组的复制

package com.lxy.exer;

public class ArrayTest_Copy_Find {
	public static void main(String[] args) {
		int[] array1,array2;
		array1 = new int[]{2,3,5,7,11,13,17,19};
		
//		显示array1的内容
		for(int i=0; i<array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
//		赋值array2变量等于array1
		array2 = array1;
		
//		修改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] + "\t");
		}
		
	}

}

数组的复制，反转，查找

package com.lxy.exer;

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

public class ArrayTest2 {
	
	public static void main(String[] args){
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
		//数组复制（区别于数组变量的赋值：arr1 = arr）
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length; i++){
			arr1[i] = arr[i];
		}
		
		//数组的反转
		// 方法一：
//		for(int i = 0; i < arr.length / 2; i++){
//			String temp = arr[i];
//			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] + '\t');
		}
		
		System.out.println();
		// 查找（或搜索）
		// 线性查找
		String dest = "BB";
		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,54,66,79,105,210,333};
		boolean isFlag1 = true;
		int dest1 = 210;
		int head = 0; // 初始首索引
		int end = arr2.length - 1; // 初始末索引
		while(head <= end){
			int middle = (head + end)/2;
			if(dest1 == arr2[middle]){
				System.out.println("找到指定的元素，位置为:" + middle);
				isFlag1 = false;
				break;
			}else if(dest1 < arr2[middle]){
				end = middle - 1;				
			}else{
				head = middle + 1;
			}
		}
		if(isFlag1){
			System.out.println("很遗憾，没找到哦！");
		}

	}

}

4.数组元素的排序算法（10大排序算法）

选择排序：直接选择排序、堆排序

交换排序：冒泡排序、快速排序

插入排序：直接插入排序、折半插入排序、Shell排序

归并排序、桶式排序、基数排序

冒泡排序：通过对待排序序列从前到后，一次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。

package com.lxy.exer;
/*
 * 数组冒泡排序的实现

 * */

public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		// 冒泡排序
		// 排arr.length - 1轮
		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] + "\t");
		}
	}

}

快速排序：排序算法中速度最快的一种，时间复杂度为O（nlog(n)）

排序思想：从数列中调一个元素，称为基准，重新排序数列，比基准小的排前面，比基准大的排后面，即为分区操作。递归地将小于基准元素的子数列和大于基准元素的子数列排序

package com.lxy.exer;

public class QuickSort {
	public static void subsort(int[] arr,int low,int high) {
		int i,j,temp,t;
		if(low > high){
			return;			
			}
		i = low;
		j = high;
		
		// temp是基准位
		temp = arr[low];
		while(i<j){
			//先看右边，依次递减
			while(temp <= arr[j] && i < j ){
				j--;
			}
			//再看左边，往右依次递增
			while(temp >= arr[i] && i < j){
				i++;
			}
			//如果满足交换条件
			if(i<j){
				t = arr[j];
				arr[j]=arr[i];
				arr[i]=t;
			}
		}
		arr[low] = arr[i];
        arr[i] = temp;
		// 递归调用左半数组
		subsort(arr,low,j-1);
		// 递归调用右左半数组
		subsort(arr,j+1,high);
		
	}
	
	public static void main(String[] args) {
		int[] arr = new int[]{10,7,2,8,9,2,6,4,5,1};
		subsort(arr,0,arr.length-1);
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + "\t");
		}
	}
		
}

5.Arrays工具类的使用

boolean equals(int[] a, int[] b)  判断两个数组是否相等

String toString(int[] a)  输出数组信息

void fill(int[] a,int val) 将指定值填充到数组中

void sort(int[] a) 对数组进行排序

int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值

6.数组使用中常见的异常：

① 数组角标越界的异常 ArrayIndexOutOfBoundException

②空指针异常 NullPointerException