2. 数组中涉及的常见算法

1. 数组的赋值（杨辉三角）

使用二维数组打印一个10行杨辉三角。
1）每一行有1个元素，第n行有n个元素
2）每一行的第一个元素和最后一个元素都是1
3）从第三行开始，对于非第一个元素和最后一个元素的元素，
即yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j]

代码：

//1.对数组进行声明和初识化
int[][] yangHui = new int[10][];

//2.对数组进行元素赋值
for(int i = 0;i < yangHui.length;i++) {
     yangHui[i] = new int[i+1];

     //对首末元素进行赋值
     yangHui[i][0] = yangHui[i][i] = 1;

     //对每行的非首末元素进行赋值
     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个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，总和，平均值，并输出。
要求：所有随机数都是两位数。

代码：

//对数组进行声明和初识化
int[] arr = new int[10];
		
//对数组进行赋值
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.print(arr[i] + " ");
}
System.out.println();
		
//求数组中所有元素的最大值
int max = arr[0];
for(int i = 1;i < arr.length;i++) {
	if(max < arr[i]) {
		max = arr[i];
	}
}
System.out.println("最大值：" + max);
		
//求数组中所有元素的最小值
int min = arr[0];
for(int i = 1;i < arr.length;i++) {
	if(min > arr[i]) {
		min = arr[i];
	}
}
System.out.println("最小值：" + min);
		
//求数组中所有元素的总和,平均值
int sum = 0;
for(int i = 0;i < arr.length;i++) {
	sum += arr[i];
}
System.out.println("总和：" + sum);
		
//求数组中所有元素的平均数
double avg = sum / arr.length;
System.out.println("平均值：" + avg);

3.数组的复制

使用简单的数组
（1）声明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的地址值一样，都指向了堆空间唯一的一个数组实体

代码：

//声明两个变量
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] + " ");
}
System.out.println();
		
//array2 = array1,将array1的地址赋给array2
array2 = array1;
		
//修改array2中的偶索引元素
for(int i = 0;i < array2.length;i++) {
	if(i % 2 == 0) {
		array2[i] = i;
	}
	//打印array1
	System.out.print(array1[i] + " ");
}

4.数组的反转

反转一个数组为AA,BB,CC,DD,EE,FF。输出结果为FF,EE,DD,CC,BB,AA

代码：

//数组的初识化和声明
String[] arr = new String[] {"AA","BB","CC","DD","EE","FF"};
		
//对数组进行遍历
for(int i = 0;i < arr.length;i++) {
	System.out.print(arr[i] + "\t");
}
System.out.println();
		
//对数组进行反转
for(int i = 0;i < arr.length / 2;i++) {
	String 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] + "\t");
}

5.数组的查找（线性和二分法）

（1）创建String[] arr = new String[] {“AA”,“BB”,“CC”,“DD”,“EE”,“FF”}，用线性查找该数组中是否存在BB。
（2）创建int[] arr2 = new int[] {-7,-4,2,8,6,47,89,420,961,1000}，用二分法查找该数组中是否存在999。

代码：

//数组的初识化和声明
String[] arr = new String[] {"AA","BB","CC","DD","EE","FF"};
		
//线性查找：
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[] {-7,-4,2,8,6,47,89,420,961,1000};
		
//要找的值
int dest1 = 999;
		
//定义首索引和尾索引
		
int head = 0;
int end = arr2.length -1;
		
boolean isFlag1 = true;
//二分法查找
while(head <= end) {
	int middle = (head + end) / 2;

	if(dest1 < (arr2[middle])) {
		end = middle - 1;
	}else if(dest1 == (arr2[middle])) {
		System.out.println("该元素在数组的位置：" + middle );
		isFlag = false;
		break;
	}else {
		head = middle + 1;
	}
} 
if(isFlag1) {
	System.out.println("很抱歉，没有找到");
}

6.冒泡排序法

数组冒泡排序的实现。

代码：

int[] arr = new int[] {1,8,4,5,4,2,6,7};
		
//冒泡排序
for(int i = 0; i < arr.length;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");
}

7.快速排序法

8.堆排序法

9.归并排序法