数组经典练习题，超配合教程的练习（四）

目录

二维数组 

1. 从定义形式上看  int[][] 2， 可以这样理解，原来的一维数组的每个元素是一维数组，就构成二维数组

练习：请用二维数组输出一下图形

 二维数组的细节和注意事项：

使用方式1： 动态初始化

二维数组的内存分析图：（非常重要）

使用方式2： 动态初始化

 使用方式3： 动态初始化--列数不确定

练习：看一个需求：动态创建下面的二维数组，并输出

 使用方式4： 静态初始化

练习：二维数组 的应用案例  ：杨辉三角

练习1：判断

        练习2：判断

int[] x,y[];//下面能通过编译的是说明：x是int 类型的一维数组，y是int 类型的二维数组

练习3：

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

画图分析（内存分析法）：

        练习4：

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

---

二维数组 

1. 从定义形式上看  int[][]
 2， 可以这样理解，原来的一维数组的每个元素是一维数组，就构成二维数组

练习：请用二维数组输出一下图形

 思路分析：

1. arr.length 表示二维数组的每个元素

2. 使用for循环遍历二维数组的每个元素（数组)

3. arr[ i ] 表示二维数组 的第 i+1个元素 ，比如 arr[ 0 ] :二维数组 的第一个元素

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

代码实现：

        //输出二维图形
        for (int i=0;i< arr.length;i++){//遍历二维数组的每个元素
            //遍历二维数组的每个元素（数组）
            //老韩解读：
            //1. arr[i]  表示二维数组的第i+1个元素，比如arr[0]：二维数组的第一个元素
            //2.  arr[i].length 得到对应的每个一维数组的长度
            for (int j=0;j< arr[i].length;j++){
                System.out.print(arr[i][j]+"");//输出了一维数组。[i]表示第几个一维数组，[j] 
           表示第几个一维数组的第几个值
            }
            System.out.println();//换行
 
        }

结果：

 二维数组的细节和注意事项：

使用方式1： 动态初始化

1. 语法：类型【】【】  数组名=new 类型【大小】【大小】
2. 比如：int a[][]=new int[2][3]

下面是使用演示：

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

结果：

下面使用内存分析图来分析上面的代码：

二维数组的内存分析图：（非常重要）

 分析： 二维数组指向一个空间，但是这个空间并不直接存放数据，为什么不直接存放数据，因为这个空间里面存放的每个元素是一维数组，而不是具体的数据，所以它要追溯一维数组的引用存放的数据。

使用方式2： 动态初始化

1. 先声明:类型 数组名【】【】；
2. 再定义（开辟空间） 数组名=new 类型【大小】【大小】
3. 赋值（有默认值，比如int 类型的就是0）
 

 下面是使用演示（代码与“使用方式1”的一致，只是“先声明，再定义”）：

       int arr[][];//声明二维数组
       arr=new int[2][3];//再开空间
 
        arr[1][1]=8;
        //遍历arr数组
        for (int i=0;i
            for (int j=0;j< arr[i].length;j++){
                System.out.print(arr[i][j]+"");
            }
            System.out.println();//换行
        }

结果：

 使用方式3： 动态初始化--列数不确定

练习：

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

代码实现：

        int[][] arr=new int[3][];//创建 二维数组 。一个有3个一维数组，但是每个一维数组还没有开数据空间
        for (int i=0;i//遍历arr每个一维数组
            //给每个一维数组开空间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输出
        System.out.println("==========arr 元素=======");
        for (int i=0;i
            for (int j=0;j
                System.out.print(arr[i][j]+"");
            }
            System.out.println();
        }

结果：

 使用方式4： 静态初始化

1. 定义 类型 数组名[][]={{值1，值2……},{值1，值2……},{值1，值2……}}
2. 使用即可【固定方向访问】
3.  比如：int[][] arr ={{1,1,1},{8,8,9},{100}}  

练习：

 代码实现：

        int arr[][]={{4,6},{1,4,5,7},{-2}};
        int sum=0;
        for (int i=0;i
            //遍历每个一维数组
            for (int j=0;j< arr[i].length;j++){
                sum+=arr[i][j];
            }
        }
        System.out.println("sum="+sum);

结果：

二维数组 的应用案例  ：杨辉三角

  练习：杨辉三角 
使用二维数组打印一个10行的
*1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
* 1 5 10 10 5 1

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

代码实现：

        int[][] yanghui=new int[10][];
        //*上面一行的代码等价于int[] yanghui[]=new int[10][];
        for (int i=0;i//遍历yanghui的每个元素
 
            //给每个一维数组（行）开空间
            yanghui[i]=new int[i+1];
            //给每个一维数组（行）赋值
            for (int j=0;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
            for (int j=0;j//遍历输出该行
                System.out.print(yanghui[i][j]+"\t");
            }
            System.out.println();//换行
        }

结果： 

---

练习1：判断

String[] strs=new String{"a","b","c"};//数组定义错误
String strs[]=new String[]{"a","b","c"};//数组定义正确
String[] strs=new String[3]{"a","b","c"};//数组定义错误，String[3]不允许有数字

---

练习2：判断

int[] x,y[];//下面能通过编译的是
说明：x是int 类型的一维数组，y是int 类型的二维数组

x[0]=y;  报错int[][]->int

y[0]=x;  正确  int[]->int[]

y[0][0]=x;  报错 int[]->int

x[0][0]=y;   错误  x[][]写法

y[0][0]=x[0];  正确  int-> int

x=y;  报错 int[][]->int

---

练习3：

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

思路  本质数组扩容+定位
* 1. 我们先确定  添加数应该插入到哪个索引
* 2， 然后扩容

遍历arr 数组，如果发现 insertNum=23< arr[i],说明 i 就是要插入的位置，就使用 index 保留index=i；
如果遍历完后，没有发现  insertNum=23< arr[i],说明 index=arr。length
即： 添加到arr 的最后

代码实现：

      int[] arr={10,12,45,90};
      int insertNum=23;
      int index=-1;//index 就是要插入的位置
     
      for (int i=0;i< arr.length;i++){
            if (insertNum<=arr[i]){
                index=i;
                break;//找到位置后，就退出
            }
        }
        //判断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 {//这个位置就是要插入是数
                arrNew[i]=insertNum;
            }
        }
        //让arr指向arrNew ，原来的数组 ，就称为垃圾，被销毁
        arr=arrNew;
 
        System.out.println("=======插入后，arr数组的元素情况======");
        for (int i=0;i
            System.out.println(arr[i]+"\t");
        }

画图分析（内存分析法）：

结果：

练习4：

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

代码实现：

       int[] arr = new int[10];
       //(int)(Math。random（）*100)+1生产 随机数1-100
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100) + 1;
        }
        System.out.println("======arr的元素情况============");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        //倒序打印
        System.out.println("======arr的元素情况(倒序)============");
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i] + "\t");
        }
        // 求平均值、求最大值和最大值的下标
        double sum = arr[0];
        int max = arr[0];
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            sum+=arr[1];//累积和
            if (max < arr[i]) {//说明max不是最大值，就变化
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("\nmax最大值="+max+"下标maxIndex="+maxIndex);
        System.out.println("\n平均值="+(sum/arr.length));
 
        //查找数组中是否有8=》使用顺序查找
        int findNum=8;
        int index=-1;//如果找到，就把下标记录到index
        for (int i=0;i
            if (findNum==arr[i] ){
                System.out.println("找到数"+findNum+"下标="+i);
                index=i;
                break;
            }
        }
        if (index==-1){
            System.out.println("没有找到数"+findNum);
        }

结果：