1、昨日复习

1.写出一维数组初始化的两种方式
int[] arr = new int[5];//动态初始化

String[] arr1 = new String[]{“Tom”,”Jerry”,”Jim”};//静态初始化

数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。

2.写出二维数组初始化的两种方式
int[][] arr = new int[4][3];//动态初始化1
int[][] arr1 = new int[4][];//动态初始化2

int[][] arr2 = new int[][]{{1,2,3},{4,5,6},{7,8}};//静态初始化

3.如何遍历如下的二维数组
int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8}};

for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + “\t”);
}
System.out.println();
}

4.不同类型的一维数组元素的默认初始化值各是多少
整型 : 0
浮点型：0.0
char:0
boolean :false
引用类型：null

5.一维数组的内存解析：
String[] strs = new String[5];
strs[2] = “Tom”;
strs = new String[3];

了解即可
数据结构：
1、数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2、数据的存储结构：
线性表：顺序表（比如：数组）、链表、栈、队列
树形结构：二叉树
图形结构：

算法：
排序算法：
搜索算法：

使用二维数组打印一个 10 行杨辉三角。 【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元
素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
package com.atguigu.java;
public class Practice {
    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 < i + 1; j++) {
                if (j == 0) {
                    yangHui[i][j] = 1;
                } else if (j == i) {
                    yangHui[i][j] = 1;
                } else if (i >= 2 && j != 0 && j != i) {
                    yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
                } else {
                    continue;
                }
            }
        }
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
//我的代码

package com.atguigu.java;
public class Practice2 {
    public static void main(String[] args) {
        // 1、声明并初始化二维数组
        int[][] yangHui = new int[10][];
        // 2、给数组元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i + 1];
            // 2.1给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            // 2.2给每行的非首末元素赋值
            if (i > 1) {//if可去掉
                for (int j = 1; j < yangHui[i].length - 1; j++) {
                    yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
                }
            }
        }
        // 3、遍历二维数组
        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();
        }
    }
}
//老师写的

2、数组中涉及的常见算法

2.1 数组元素的赋值

【拓展之笔试题】
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求
元素的值各不相同。
package com.atguigu.java;
import java.util.Random;
/*
 * 【拓展之笔试题】
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求
元素的值各不相同。
 */
public class Practice3 {
    public static void main(String[] args) {
        // 1、创建数组
        int[] arr = new int[6];
        int number = 0;
        // 2、赋值
        // 2.1赋值并判断
        for (int i = 0; i < arr.length; i++) {
            number = (int) (Math.random() * 30 + 1);
            if(i >0){
                for(int j=0;j<i;j++){
                    if(arr[j]==number){
                        i--;
                        break;
                    }else{
                        arr[i] =number;
                    }
                }
            } else{
                arr[i] =number;
            }
        }
        // 3、遍历
        for (int i1 = 0; i1 < arr.length; i1++) {
            System.out.println(arr[i1]);
        }
    }
}
//我写的

        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
            arr[i] = (int) (Math.random() * 30) + 1;
                for (int j = 0; j < i; j++) {
                    if (arr[i] == arr[j]) {
                        i--;
                        break;
                    }
                }
            }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
//老师的

2.2 求数值型数组中元素的最大值、最小值、平均值、总和等

package com.atguigu.java;
/*
 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。
 */
public class Practice4 {
    public static void main(String[] args) {
        //1 定义一个int型的一维数组，包含10个元素
        int[] arr = new int[10];
        //2 分别赋一些随机整数，
        for (int i = 0; i < 10; i++) {
            arr[i] = (int) (Math.random() * 90 + 10);
        }
        for(int i=0;i<10;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //3 求出所有元素的最大值，最小值，和值，平均值，并输出出来。
        //3.1 最大值
        int max=0;
        for(int i=0;i<10;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("最大值是："+max);
        //3.2 最小值
        int min=0;
        for(int i=0;i<10;i++){
            if(arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最小值是："+min);
        //3.3 和值，平均值
        int sum=0;
        int avage=0;
        for(int i=0;i<10;i++){
            sum+=arr[i];
        }
        avage=sum/10;
        System.out.println("和值是："+sum+"，平均值是："+avage);
    }
}

2.3 数组的复制、反转、查找（线性查找、二分法查找）

package com.atguigu.java;
/*
 * 使用简单数组
(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
(如array[0]=0,array[2]=2)。打印出array1。
 */
public class Practice5 {
    public static void main(String[] args) {
        int[] array1 = new int[]{2,3,5,7,11,13,17,19};
        int[] array2;
        for(int i=0;i<array1.length;i++){
            System.out.print(array1[i]+" ");
        }
        System.out.println();
        array2=array1;
        for(int i=0;i<array2.length;i++){
            if(i%2==0){
                array2[i]=i;
            }
        }
        for(int i=0;i<array1.length;i++){
            System.out.print(array1[i]+" ");
        }
    }
}
思考：array1和array2是什么关系？array1和array2地址值一样
拓展：修改题目，实现array2对array1数组的复制

QQ截图20211206165223.png

//查找
//线性查找：
//二分法查找：要求此数组必须是有序的。

2.4 数组元素的排序算法

排序：假设含有n个记录的序列为{R1，R2，…,Rn},其相应的关键字序列为
{K1，K2，…,Kn}。将这些记录重新排序为{Ri1,Ri2,…,Rin},使得相应的关键
字值满足条Ki1<=Ki2<=…<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。
排序算法分类：内部排序和外部排序。
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

QQ截图20211207141537.png
要求：知道有十种，冒泡排序和快速排序必须要会手写，堆排序和归并排序了解思想
QQ截图20211207142118.png

package com.atguigu.java;
public class Practice7 {
    public static void main(String[] args) {
        int[] arr = new int[] { 43, 32, 76, -98, 0, 64, 33, -21, 32, 99 };
        // 冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j]>arr[i]){
                    int 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");
        }
    }
}

附录：尚硅谷宋红康排序算法.pdf

3、Arrays工具类的使用

QQ截图20211207151007.png
QQ截图20211207152207.png

Java 学习知识库

Day07