第六章 数组、排序和查找——查找（3）

一、查找

1.介绍

在java中，常用的查找有两种：

（1）顺序查找

（2）二分查找

2.案例演示

（1）有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王。猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】。要求：如果找到了，就提示找到，并给出下标值。

import java.util.Scanner;
public class SeqSearch {
	public static void main(String[] args) {
		/*
		思路分析：
		1. 定义一个字符串数组
		2. 接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出
		 */
		
		//定义一个字符串数组
		String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
		Scanner myScanner = new Scanner(System.in);

		//接收用户输入
		System.out.println("请输入名字：");
		String findName = myScanner.next(); //接收用户输入的字符串信息

		//遍历数组，逐一比较，如果有，则提示信息，并退出
		int index = -1;
		for(int i = 0; i < names.length; i++) {
			//比较 字符串比较 equals
			if(findName.equals(names[i])) {
				System.out.println("恭喜你找到" + findName + "\n它的下标是" + i);
				index = i; //把i保存到index
				break;
			}
		}
		if(index == -1) {
			System.out.println("没有找到" + findName);
		}
	}
}

二、多维数组-二维数组

1.介绍

（1）应用场景：比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。

（2）二维数组的定义：

1）数组的嵌套，二维数组的每个元素是一维数组，它的各个一维数组的长度可以相同，也可以不相同。

2）访问二维数组中第0个元素的第1个值 arr[0][1].

 （3）请用二维数组输出如下图形：

0 0 0 0 0 0

0 0 1 0 0 0

0 2 0 3 0 0

0 0 0 0 0 0

public class TwoDimensionalArray01 {
	public static void main(String[] args) {
		/*
		什么是二维数组？
		1.从定义形式上看 int[][]
		2.可以这样理解，原来的一维数组的每个元素是以为数组，就构成二维数组
		 */
		int[][] arr = { {0, 0, 0, 0, 0, 0}, 
						{0, 0, 1, 0, 0, 0}, 
						{0, 2, 0, 3, 0, 0}, 
						{0, 0, 0, 0, 0, 0} };

		//输出二维图形
		for(int i = 0; i < arr.length; i++) {
			/*
			1.arr[i] 表示 二维数组的第i个元素 比如：arr[0]:二维数组的第0个元素
			2.arr[i].length 表示二维数组的第i个元素的数组长度
			 */
			for(int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + " "); //输出了第i个元素的数组
			}
			System.out.println(); //换行
		}
	}
}

2.二维数组的使用

（1）使用方式1——动态初始化

1）语法

A. 数据类型[ ][ ] 数组名 = new 数据类型[大小][大小]/

    数据类型 数组名[ ][ ] = new 数据类型[大小][大小]/

    数据类型[ ] 数组名[ ] = new 数据类型[大小][大小]

    例如：int[][] a = new int[2][3]

B. 先声明：数据类型[ ][ ] 数组名 / 数据类型 数组名[ ][ ]

    再定义（开辟空间）：数组名 = new 数据类型[大小][大小]

第一个“大小”代表二维数组中元素（一维数组）的个数。

第二个“大小”代表每一维数组中元素的个数。

2）二维数组在内存的存在形式

public class TwoDimensionalArray02 {
	public static void main(String[] args) {

		//创建一个二维数组arr，其有2个元素（一维数组），每个一维数组包含3个元素
		int[][] arr = new int[2][3];

		arr[1][1] = 8;
		//遍历arr数组
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println(); //换行
		}
	}
}
/*
输出：
0 0 0
0 8 0
 */

（2）使用方式2——动态初始化-列数不确定

需求：动态创建下面的二维数组，并输出。

public class TwoDimensionalArray03 {
	public static void main(String[] args) {
		/*
		需求：动态创建下面二维数组，并输出
		i = 0:1
		i = 1:2 2
		i = 2:3 3 3

		一共有三个一维数组，每个一维数组的元素个数是不一样的
		 */
		
		int[][] arr = new int[3][]; //创建二维数组，一共有3个一维数组，但是每个一维数组还没有开数据空间
		for(int i = 0; i < arr.length; i++) { //遍历arr每一个一维数组
			//给每个一维数组开空间 new
			//如果没有给一维数组new，那么arr[i]就是null
			arr[i] = new int[i + 1]; //第0个一维数组的元素个数为1，1——2，2——3，i——i+1
			
			//遍历一维数组，并给一维数组的每个元素赋值
			for(int j = 0; j < arr[i].length; j++) {
				arr[i][j] = i + 1; //赋值，第0个一维数组的元素全为1，1——2，2——3，i——i+1

			}
		}

		System.out.println("=====arr的元素情况=====");
		//遍历arr输出
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println(); //换行
		}
	}
}
//给第0个一维数组开空间、赋值→给第2个一维数组开空间、赋值→给第3个一维数组开空间、赋值

（3）使用方式3——静态初始化

1）定义

类型 数组名[ ][ ] = {{值1，值2，值3，...}，{值1，值2，值3，...}，{值1，值2，值3，...}...}

例如：int arr[ ][ ] = {{1，1，1}，{8，8，9}，{100}}

定义了一个int类型的二维数组 arr；arr有三个元素（每个元素都是一维数组）；第一个一维数组有3个元素，第二个一维数组有三个元素，第三个一维数组有1个元素。

public class TwoDimensionalArray04 {
	public static void main(String[] args) {

		int arr[][] = {{1,1,1},{8,8,9},{100}};
		//int arr[][] = {{1,1,1},{8,8,9},100}; 
		//第三个一维数组虽只有一个元素，但{}不可省略；若省略{}，100便是基本数据类型int,与声明的数据类型int[]不一致

	}
}

2）练习

练习1：int[ ][ ] arr = {{4,6},{1,4,5,7},{-2}};遍历该二维数组，并得到和。

public class TwoDimensionalArray05 {
	public static void main(String[] args) {

		//定义二维数组——静态初始化
		int[][] arr = {{4,6},{1,4,5,7},{-2}};
		int sum = 0;

		for(int i = 0; i < arr.length; i++ ) {
			for(int j = 0; j < arr[i].length; j++) {
				sum += arr[i][j];
			}
		}

		System.out.println("这个二维数组的和是" + sum);//25
	}
}

练习2：使用二维数组打印一个10行的杨辉三角

/*
输出10行的杨辉三角
杨辉三角的规律：
1.第1行有1个元素，第n行有n个元素。
2.每一行的第一个元素和最后一个元素都是1.
3.从第三行开始，对于非第一个元素和最后一个元素的元素的值arr[i][j]
arr[i][j] = arr[i-1][j] + arr[i-1][j-1];

 */
public class YangHui {
	public static void main(String[] args) {

		int[][] yanghui = new int[10][];
		for(int i = 0; i < yanghui.length; i++) {

			yanghui[i] = new int[i + 1];

			for(int j = 0; j < yanghui[i].length; j++){
				if(j == 0 || j == yanghui[i].length - 1){
					yanghui[i][j] = 1;
				}else {
					yanghui[i][j] = yanghui[i-1][j] + yanghui[i-1][j-1];
				}
			}
		}

		for(int i = 0; i < yanghui.length; i++) {
			for(int j = 0; j < yanghui[i].length; j++) {
				System.out.print(yanghui[i][j] + "\t"); //\t实现对齐功能
			}
			//换行，System.out.print()是错误的，但System.out.println()是正确的
			System.out.println();
		}
	}
}

三、数组的细节

名称	定义方式
一维数组	int[ ] x 或者 int x[ ]
二维数组	int[ ][ ] y 或者 int[ ] y[ ] 或者 int y[ ][ ]

四、作业

1.作业一

已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，如：[10,12,45,90]，添加23后，数组为[10,12,23,45,90].

（1）解法一：

import java.util.Scanner;
public class Homework04 {
	public static void main(String[] args) {

		/*
		思路分析：
		1.先扩容，将新元素添加至数组最后
		2.再排序，将新元素挪至合适位置
		 */

		//定义初始数组
		int[] arr = {10, 12, 45, 90};

		//创建Scanner对象
		Scanner myScanner = new Scanner(System.in);

		do{
			//定义一个新的数组
			int[] arrNew = new int[arr.length + 1];

			//遍历arr数组，依次将arr的元素拷贝到arrNew数组
			for(int i = 0; i < arr.length; i++) {
				arrNew[i] = arr[i];
			}

			//接收用户输入，并赋给arrNew的最后一个元素
			System.out.println("请输入你要添加的元素：");
			arrNew[arrNew.length - 1] = myScanner.nextInt();

			//将arr指向arrNew
			arr = arrNew;

			//将新添加的元素，从后向前挪到合适的位置
			//将新元素与其左侧相邻的元素进行比较，若左侧相邻的元素>新元素，就交换位置；
			//直到其左侧相邻的元素<新元素，退出排序循环
			int temp = 0;
			for(int j = 0; j < arr.length - 1; j++) {
				if(arr[arr.length -2 -j] > arr[arr.length -1 -j]) {
					temp = arr[arr.length - 2 - j];
					arr[arr.length - 2 -j] = arr[arr.length -1 - j];
					arr[arr.length - 1 - j] = temp;
				}else {
					break;
				}
			}

			for(int m = 0; m < arr.length; m++) {
				System.out.print(arr[m] + "\t");
			}

			//换行
			System.out.println();
			//问用户是否继续添加
			System.out.println("是否继续添加元素？y/n");
			char key = myScanner.next().charAt(0);
			//如果输入n就结束
			if(key == 'n') {
				break;
			}

		}while(true);		
	}
}

（2）解法二：

public class Homework042 {
	public static void main(String[] args) {
		/*
		思路分析：本质是数组扩容＋定位
		1.先确定添加数应该插入到哪个索引
		2.然后扩容
		 */
		
		//先定义原数组
		int[] arr = {10, 12, 45, 90};
		int insertNum = 23;
		int index = -1; //index就是要插入的位置

		//遍历arr数组，如果发现insertNum <= arr[i],说明i就是要插入的位置
		//使用index 保留 index = i;
		//如果遍历完后，没有发现insertNum <= arr[i],说明 index = arr.length，即添加到arr的最后
		
		for(int i = 0; i < arr.length; i++) {
			if(insertNum <= arr[i]) {
				index = i;
				break; //找到位置后就退出，如果不退出，后面的元素也满足insertNum <= arr[i]
			}
		}

		//判断index的值
		if(index == -1) { //说明没有找到位置
			index = arr.length;
		}


		//扩容
		//先创建一个新的数组，大小为arr.length + 1
		int[] arrNew = new int[arr.length + 1];
		//将arr的元素拷贝到arrNew,并且要跳过index位置
		/*
		分析：
		int[] arr = {10, 12, 45, 90};
		arrNew = {  ,  ,  ,  ,  }
		 */
		for(int i = 0, j = 0; i < arrNew.length; i++) {
			if(i != index) { //说明可以把arr的元素拷贝到arrNew
				arrNew[i] = arr[j];
				j++;
			} else { //i这个位置就是要插入的数
				arrNew[i] = insertNum;
			}
		}

		//让arr指向arrNew，原来的数组就成为垃圾被销毁
		arr = arrNew;

		System.out.println("====插入后，arr数组的元素情况====");
		for(int m = 0; m < arr.length; m++) {
			System.out.print(arr[m] + "\t");
		}
		
	}
}

2.作业二

随机生成10个整数（1-100的范围），保存到数组中，并倒序打印以及求平均值、最大值和最大值下标，并查找里面是否有8.

public class Homework05 {
	public static void main(String[] args) {

		int[] arr = new int[10];
		int sum = 0;
		int max = 0; //最大值
		int maxindex = -1; //最大值的下标

		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100) + 1; //随机生成1-100间的整数
			sum += arr[i]; //求和

			if(arr[i] > max) { //边生成边得到最大值及其下标
				max = arr[i];
				maxindex = i;
			}

			if(arr[i] == 8) { //判断生成的数组中是否有8
				System.out.println("该数组中有8。");
			}
		}

		System.out.println("===arr的元素情况===");
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println("\n===arr的元素情况(逆序)===");
		//方法一
		for(int j = 0; j < arr.length; j++) {
			System.out.print(arr[arr.length - 1 -j] + "\t");
		}
		//方法二
		// for(int j = arr.length - 1; j >= 0; j--) {
		// 	System.out.print(arr[j] + "\t");
		// }

		//求平均值,平均值可能是小数
		double average = sum / arr.length;

		System.out.println("\n平均值=" + average);
		System.out.println("最大值=" + max);
		System.out.println("最大值下标=" + maxindex);
	}
}

3.作业三

冒泡排序

public class Homework07 {
	public static void main(String[] args) {

		//冒泡排序
		//要求从小到大排序
		int[] arr = {20, -1, 89, 2, 890, 7, 99, 88};
		int temp = 0; //辅助交换

		for(int i = 0; i < arr.length - 1; i++) { //外层循环（轮）
			for(int j = 0; j < arr.length - 1 - i; j++) { //每轮的比较次数
				//如果是从小到大，条件是 arr[j] > arr[j+1]
				//如果是从大到小，条件是 arr[j] < arr[j+1]
				if(arr[j] > arr[j + 1]) {
					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");
		}

	}
}