Java 数组、排序和查找（3）

最新推荐文章于 2024-03-08 00:07:16 发布

周小末天天开心

最新推荐文章于 2024-03-08 00:07:16 发布

阅读量1.3k

点赞数 16

分类专栏： Java基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_71646897/article/details/127200231

版权

Java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

前言

国庆第七天！数组、排序和查找复习完成。

一、数组查找

（1）查找分类

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

1）顺序查找

2）二分查找

（2）顺序查找

案例：

有一个数列：{"java" , "python" , "golang"};
从键盘输入一组字符串判断数列中是否包含此字符串(顺序查找)
要求：如果找到了，就提示找到，并给出下标值；没找到就给出提示

思路：
1. 定义一个字符串数组
2. 接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出

直接上代码：

import java.util.Scanner;
public class SeqSearch {
	public static void main(String[] args) {
		
		//定义一个字符串数组
		String[] names = {"java" , "python" , "golang"};
		Scanner myScanner = new Scanner(System.in);

		System.out.println("请输入字符串：");
		String findName = myScanner.next();

		//遍历数组，逐一比较，如果有则提示信息并退出
		//判断有没有成功可以用一个 索引/标识符/标记 等
		int index = -1; //不能为 i - names.equals 间的数
		for(int i = 0; i < names.length ; i++) {
			//比较字符串  equals , 如果要找到名字就是当前元素
			if(findName.equals(names[i])) {
				System.out.println("恭喜你找到了" + findName);
				System.out.println("下标为：" + i);
				// 将i保存到index
				index = i;
				break; // 退出

			}
		}
		if(index == -1) {
			System.out.println("sorry , 没有找到" + findName);
		}
	}
}

输出结果为：

可以看出在找到字符串后便会提示找到并且输出该字符串的下标。

未找到便会提示 sorry，没有找到。

二、二维数组

（1）快速入门

/*
       请用二维数组输出如下图形
       0 0 0 0 0 0
       0 0 1 0 0 0
       0 2 0 3 0 0
       0 0 0 0 0 0
       */

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

		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++) {// 遍历二维数组的每个元素

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

				System.out.print(arr[i][j] + " "); // 输出二维数组
			}
			System.out.println( );  // 换行

		}
	}
}

结果为：

分析：

1）arr[i] 表示一维数组的第i + 1个元素。比如：arr[0] : 一维数组的第一个元素

2）arr[i].length 会得到对应的每个一维数组的长度

3）访问第 (i + 1) 个一维数组的第 (j + 1) 个值即 arr[i][j];

例如：访问3行 4列，它是第三个一维数组的第四个值 arr[2][3]；

（2）动态初始化

1）使用方法1

语法：

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

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

演示：

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

		int[][] arr = new int[2][3];

		arr[1][1] = 8; // 将arr[1][1]改为 8
		//遍历数组
		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();// 换行

		}	
	}
}

输出为：

注意：未赋值的情况下int类型的默认值为 0

2）使用方法2

语法：先声明，再定义

类型[ ] [ ] 数组名;

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

例如：int[ ] [ ] arr;

arr = new int[2] [3];

3）使用方法3

动态初始化—列数不确定

案例：

动态创建下面的二维数组

j = 0 j = 1 j = 2
i = 0 1
i = 1 2 2
i = 2 3 3 3

演示：

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

		int[][] arr = new int[3][]; 
            // 创建 二维数组，一共有三个一维数组，但是每个一维数组都还没有开空间
		for(int i =0 ; i < arr.length ; i++) {  // 遍历每个一维数组
			// 给每一个一维数组开空间 new
			//  如果没有给一维数组 new 开空间。 那么 arr[i] 就是 null
			arr[i] = new int[i + 1];

			//遍历一维数组，并给每个一维数组元素 赋值
			for(int j = 0 ; j < arr[i].length ; j++) {

				arr[i][j] = i + 1;// 赋值
			}
		}

		// 遍历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();
		}
		
	}
}

结果为：

（3）静态初始化

语法：

类型[ ] [ ] 数组名 = {{值1, 值2} , {值1, 值2} , {值1, 值2}};

例如：int[ ] [ ] arr = {{1, 2, 3} , {4, 5, 6} , {7, 8, 9}};

（4）使用细节

1）二维数组的声明方式有：

int[ ] [ ] arr 或 int arr[ ] [ ]

2）二维数组实际上是由多个一维数组组成的，它的各个一维数组长度可以相同，也可以不同。

三、应用案例（杨辉三角）

使用二维数组，打印一个10行的杨辉三角

        1
       1 1
       1 2 1
       1 3 3 1
       1 4 6 4 1
       1 5 10 10 5 1

        ……

规律：

1）第一行有一个元素第 n 行有 n 个元素

2）每一行第一个元素和最后一个元素都为 1

3）从第三行开始，对于非第一个元素和最后一个元素的值

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++) {
				//每一行的第一个元素和最后一个元素都是1
				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] + "  ");
			}
			System.out.println();
		}
	}
}

输出结果为：