(三)java二维数组、数组中常用的算法、调试

1. 二维数组

1.1 概念

对于二维数组的理解，我们可以看成是一维数组的元素中存放另一个数组的地址。其实，从数组底层的运行机制来看，其实没有多维数组

1.2 格式

格式一：
int[][] arr = new int[3][2]

• 定义了名称为arr的二维数组
• 二维数组中有三个一维数组
• 每一个一维数组中有两个元素
• 一维数组名称为 arr[0],arr[1],arr[2]

格式二：
int[][] arr = new int[3][]

• 每个一维数组都是默认初始值null
• 对一维数组初始化操作： arr[0] = new int[5]

格式三：
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

• 二维数组中有三个一维数组
• 每一个一维数组都被初始化
• 一维数组的长度表示为 arr[2].length：3，2，4

1.3 内存结构

int[][] arr2 = new int[][]{{3,8,2},{2,7}, {9,0,1,6}};

1.4 练习

计算3个班级所有学生的平均分

import java.util.Scanner;
public class Test2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //定义了三个班级
        double[][] score = new double[3][];
        for (int i = 0; i < score.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个班级人数:");
            //键入班级人数
            int count = scanner.nextInt();
            score[i] = new double[count];
            //键入班级的成绩
            System.out.println("请输入第" + (i + 1) + "个班级各学生的成绩");
            for (int j = 0; j < count; j++) {
                score[i][j] = scanner.nextDouble();
            }
            //打印平均分
            double sum = 0;
            for (int k = 0; k < score[i].length; k++) {
                sum += score[i][k];
            }
            System.out.println("第" + i + 1 + "个班级的平均分为" + sum / count);
        }
    }
}

2. 数组中常见算法

2.1 复制、反转、线性查找

import java.util.Arrays;
public class Test3 {
    public static void main(String[] args) {
        //复制
        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = arr[i];
        }
        //反转
        String temp;
        for (int i = 0, j = arr.length - 1; i < j; i++,j--) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

线性查找

public class Test4 {
    //线性查找
    public static void main(String[] args) {
        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
        String dest = "aa";
        boolean isFlag = false;
        for (int i = 0; i < arr.length; i++) {
            if (dest.equalsIgnoreCase(arr[i])) {
                System.out.println("找到了,下标为：" + i);
                isFlag = true;
                break;
            }
        }
        if (isFlag == false) {
            System.out.println("很遗憾，数组中不存在" + dest);
        }
    }
}

2.2 二分查找

public class Test5 {//二分查找

    public static void main(String[] args) {
        int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int dest1 = -98;
        boolean isFlag = false;
        int head = 0;
        int end = arr2.length - 1;
        int middle;
        while (head <= end) {
            middle = (head + end) / 2;
            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，下标为：" + middle);
                isFlag = true;
                break;
            }
            if (dest1 > arr2[middle]) {
                head = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        if (isFlag == false){
            System.out.println("没找到");
        }
    }
}

2.3 冒泡排序

衡量排序算法的优劣：

• 时间复杂度：分析关键字的比较次数和记录的移动次数
• 空间复杂度：分析排序算法中需要多少辅助内存
• 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

import java.util.Arrays;
public class Test6 {//冒泡排序
    public static void main(String[] args) {
        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {// i 控制循环次数，10个数进行9次循环
            for (int j = 0; j < arr.length - 1 - i; j++) {//10个数 下标最大值为9 j只需要到8，此时j + 1 =9;
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2.4 Arrays工具类

import java.util.Arrays;

public class Test7 {//Arrays工具类

    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4};
        int[] arr2 = {1, 2, 3, 4};

//1.判断两个数组是否相等
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);
//2.输出数组的信息
        System.out.println(Arrays.toString(arr1));
//3.将指定值填充到数组中
        Arrays.fill(arr1, 10);

//4.对数组进行排序
        Arrays.sort(arr2);

//5.二分查找
        int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr3, 333);
        String outPut = index >= 0 ? "找到了，下标为：" + index : "未找到";
        System.out.println(outPut);

    }
}

3. 二分查找调试

• 设置断点
• 调试运行
• f8执行一行
• f7进入这行代码执行
• shift + f8：跳出
  1. 设置断点，并跳入binarySearch()方法
  

2. 在binarySearch()方法中传入了数组的引用，长度，和要查找的值。
并跳入binarySearch0()方法

3. 执行到如下行时，完成了给low 和high的赋值

4. 将key与中间的值进行比较， key的值大于中间值，所以low = mid + 1;
这次循环结束，且满足 low <= high 继续寻找

5.key的值为333，位于最后一行 ，循环到最后low 等于high，且中间值与key相等
返回mid的值，然后上面的两种方法依次出栈

6. 最后回到main方法
判断index 的值是否为大于等于0的数， 并打印输出