第七章-二维数组

第七章-二维数组

1、冒泡排序 – 升序

原理：
    每次比较相邻两数
    小的交换到前面
    每轮结束后最大的数交换到最后

口诀：
    冒泡排序速记口诀（升序）
        n 个数字来排队
        两两相比大靠后
        外层循环 n-1
        内层循环 n-1-i

示例：
        // 冒泡排序算法
        // 初始化一个数组
		int[] nums = {6, 3, 5, 2, 7, 4, 1, 9, 8};
		System.out.println("排序前：" + Arrays.toString(nums));
		// 外层控制轮次（n-1次）
		for (int i = 0; i < nums.length - 1; i++) {
			// 内层控制比较次数
			for (int j = 0; j < nums.length - 1 - i; j++) {
				// 判断，如是升序，大的值靠后，如果是降序，小的值靠后
				if(nums[j] < nums[j + 1]){
					// 两值互换
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		System.out.println("排序后：" + Arrays.toString(nums));

2、选择排序

/**
 * 工作原理：
 * 首先在未排序的数列中找到最大（小）元素，放到排序数列的起始位置
 * 然后再从剩余未排序的元素中继续查找最大（小）元素，放到已排序数列的末尾（按照次序），依次类推
 * @author zhukang
 *
 */
public class Xuanze {

	public static void main(String[] args) {
		// 选择排序：表现最为文档的一种排序，其排序算计简单直观
		// 初始化一个数组
		int[] nums = {6, 3, 5, 2, 7, 4, 1, 9, 8};
		System.out.println("排序前：" + Arrays.toString(nums));
		for (int i = 0; i < nums.length; i++) {
			int minIndex = i;
			for (int j = i; j < nums.length; j++) {
				// 找最小值
				if(nums[j] < nums[minIndex]){
					// 将最小值的下标记录下来
					minIndex = j;
				}
			}
			// 将最小值下标对应的元素跟外层每轮循环起始下标元素交换
			int temp = nums[minIndex];
			nums[minIndex] = nums[i];
			nums[i] = temp;
		}
		System.out.println("排序后：" + Arrays.toString(nums));
	}

}

3、Arrays工具类的用法

boolean equals(array1,array2)
    比较array1和array2两个数组是否相等
sort(array)
    对数组array的元素进行升序排列
String toString(array)
    将一个数组array转换成一个字符串
void fill(array,val)
    把数组array所有元素都赋值为val
copyOf(array,length)
    把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int binarySearch(array, val)
    查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

示例：
    	// Arrays工具类对数组的常用方法
		// 1 比较两个数组是否相等：equals(数组1， 数组2)
		int[] num1 = { 1, 3, 5, 8, 9 };
		int[] num2 = { 1, 3, 5, 7, 9 };
		System.out.println("两个数组是否相等：" + Arrays.equals(num1, num2));

		// 2 填充数组元素：fill(数组名，填充值)
		int[] num3 = new int[8];
		System.out.println("默认值：" + Arrays.toString(num3));
		Arrays.fill(num3, 4);
		System.out.println("填充后：" + Arrays.toString(num3));
		
		// 3 数组拷贝：copyOf(原始数组, 拷贝新数组长度) 有返回值（返回跟当前数组类型一致的新数组）
		int[] num4 = {3, 4, 6, 2, 5};
		System.out.println("原始数组：" + Arrays.toString(num4));
		int[] num5 = Arrays.copyOf(num4, 8);
		System.out.println("拷贝后新数组1：" + Arrays.toString(num5));
		int[] num6 = Arrays.copyOf(num4, 3);
		System.out.println("拷贝后新数组2：" + Arrays.toString(num6));
		
		// 4 数组元素查找 : binarySearch(目标数组，元素) 注意前置条件：必须是升序，返回值是元素在排序后的下标
		int[] num7 = {8, 4, 2, 6, 10};
		System.out.println("查找数组内容：" + Arrays.toString(num7));
		Arrays.sort(num7);
		System.out.println("查找数组排序后内容：" + Arrays.toString(num7));
		System.out.println("4在数组中的位置：" + Arrays.binarySearch(num7, 4));
		// 如果不在数组中，返回值肯定是小于0
		System.out.println("3在数组中的位置：" + Arrays.binarySearch(num7, 2));
		
		// 5 数组排序：sort 默认升序
		String[] names = {"marry", "tom", "mark", "jack"};
		System.out.println("字符串数组排序前：" + Arrays.toString(names));
		Arrays.sort(names);
		System.out.println("字符串数组排序后：" + Arrays.toString(names));

4、二维数组

语法：
    <数据类型> [ ][ ]  数组名 = new 数据类型[数组二维长度][数组一维长度];  
    或者  
    <数据类型>  数组名[ ][ ] = new 数据类型[数组二维长度][数组一维长度];  
注意：
    定义二维数组时，要定义最大维数，一维维度可以不定义，且长度不是必须一致的
    二维数组实际上是一个以一维数组做为元素的一维数组
    通过二维数组名获取长度，返回的是二维的长度，即有几个一维数组

示例：
    int [ ][ ] scores = new int[5][]; -- 正确
    int [ ][ ] scores = new int[][]; -- 错误

定义并赋值：
    int[][] scores = new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
    或者
    int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

遍历二维数组：
		// 外层是二维长度
		for (int i = 0; i < scores.length; i++) {
			// 内层是一维数组的真是长度
			for (int j = 0; j < scores[i].length; j++) {
				System.out.print(scores[i][j] + " ");
			}
			System.out.println();
		}
示例：
        // 按规律输出数字列表
        /**
		 * 特殊数列
		 * 1
		 * 2 6
		 * 3 7 10
		 * 4 8 11 13
		 * 5 9 12 14 15
		 */
		Scanner input = new Scanner(System.in);
		System.out.print("请输入数列的行数：");
		int line = input.nextInt();
		// 定义二维数组存放数据
		int[][] nos = new int[line][line];
		
		// 定义初始值为1，进行累加
		int num = 1;
		
		// 给二维数组赋值
		for (int i = 0; i < nos.length; i++) {
			for (int j = i; j < nos[i].length; j++) {
				nos[j][i] = num++;
			}
		}
		
		// 遍历二维数组，排除默认值0
		for (int i = 0; i < nos.length; i++) {
			for (int j = 0; j < nos[i].length; j++) {
				// 如果是0，不输出
				if(nos[i][j] == 0){
					continue;
				}
				System.out.print(nos[i][j] + " ");
			}
			System.out.println();
		}
		input.close();