从零开始的Java开发基础-----二维数组

二维数组:

概念

存储数组的数组

名词

长度:二维数组中一维数组的个数
元素:一个一维数组
下标(索引):一维数组在二维数组中的位置

步骤

1.声明
    数据类型[][] 数组名;
2.创建
    动态:
        带值
            数组名=new int[][]{
             {值1,值2.....},{},{}
            }
        不带值
            数组名=new int[x][y];
            x:二维数组中一维数组的个数(长度)
            y:一维数组中元素的个数  可写可不写
        特点:
            可以将声明与创建分开 也可以在同时进行
    静态:
        数据类型[][] 数组名={
        {值1,值2.....},{},{}
        }
3.操作
    改:
        修改指定位置的一维数组
            数组名[] = 新的一维数组
        修改指定位置的元素
            数组名[下标1][下标2] = 值
            下标1:一维数组在二维数组中的位置
            下标2:元素在一维数组中的位置
        修改整个二维数组
    查:
        查询指定位置的一维数组:
            数组名[]
        查询指定位置的元素
            数组名[下标1][下标2]
            下标1:一维数组在二维数组中的位置
            下标2:元素在一维数组中的位置
        查询二维数组的长度
            数组名.length
            注意:是二维数组中一维数组的个数,不是所有元素的个数

特殊情况

遍历:
思想:
    逐个获取二维数组中的一维数组
    逐个获取一维数组中的每个元素

杨辉三角

二维数组的经典例题
0       1   0   0   0   0   0   0   0   0   0   0   0   
1       1   1   0   0   0   0   0   0   0   0   0   0   
2       1   2   1   0   0   0   0   0   0   0   0   0   
3       1   3   3   1   0   0   0   0   0   0   0   0   
4       1   4   6   4   1   0   0   0   0   0   0   0   
5       1   5   10  10  5   1   0   0   0   0   0   0   
6       1   6   15  20  15  6   1   0   0   0   0   0   
7       1   7   21  35  35  21  7   1   0   0   0   0   
8       1   8   28  56  70  56  28  8   1   0   0   0   
9       1   9   36  84  126 126 84  36  9   1   0   0   
10      1   10  45  120 210 252 210 120 45  10  1   0   
11      1   11  55  165 330 462 462 330 165 55  11  1
i
    j   0   1   2   3   4   5   6   7   8   9   10  11
    特点:
        当 i=j或者j=0时  该位置是1
        用 [i][j]=[i-1][j]+[i-1][j-1]

算法:

人:图灵
奖项:图灵奖
计算机:图灵机
图灵说:软件就是算法+数据结构

概念

公式

优点:

提高计算机的运算符效率
如:
    //原来的
    int sum = 0;
    for(int i = 1; i < 101; i++){
        sum = sum + i;
    }
    System.out.println(sum);
    
    数学公式:(首项+尾项)*项数/2
    int sum = (1+100)*100/2;

如何判断算法是否优秀

时间复杂度:代码执行的时长越短越好
空间复杂度:代码在运行时占用的内存越少越好

常见的算法

两数交换:
    int a = 10;
    int b = 5 ;
    int c = a ;
    a = b;
    b = c;
​
寻找最值:
    int[] nums = {10,20,30,4,50,20,22}
    //寻找最大值
    //假设一个数为最大值 必须是数组中的数
    int max = nums[];
    //循环获取数组中所有的数与假设的最大值比较
    for(int i = 0 ;i<nums.length;i++){
    //获取数组中i位置的值
    int x = nums[i];
    //使用获取的值与假设的最大值比较
    if(x>max){
        max = x;
    }
    }
    sout(max);
    
将最小值或最大值移动到最后
    冒泡:
        思想:相邻比较,交换位置
        代码:
            int[] nums = {10,20,30,4,50,20,22};
            for (int i = 0; i < nums.length-1; i++) {
                if (nums[i] > nums[i+1]) {
                    int temp = nums[i];
                    nums[i]=nums[i+1];
                    nums[i+1] = temp;
                }
            }
     冒泡排序:相邻相比,换位置
            int[] nums = {10,20,30,4,50,20,22};
            for (int j = 0; j < nums.length-1; j++) {
                for (int i = 0; i < nums.length-1; i++) {
                if (nums[i] > nums[i+1]) {
                    int temp = nums[i];
                    nums[i]=nums[i+1];
                    nums[i+1] = temp;
                }
            }
     选择排序:将后面数组的最大值换到对应位置
            int[] nums = {10,20,30,4,50,20,22};
        for (int j = 0; j < nums.length-1; j++) {
        
            //要转换到的位置
            int tagIndex=j;
            //假设最大数字的位置
            int maxIndex=j;
            
            for (int i = j+1; i < nums.length; i++) {
                if (nums[maxIndex]<nums[i]) {
                    maxIndex=i;
                }
            }
            //真实最大数字的位置是maxIndex
            //如果目标位置和最大数位置不同,转换
            if(maxIndex!=tagIndex){
                int c = nums[tagIndex];
                nums[tagIndex]=nums[maxIndex];
                nums[maxIndex]=c;
            }
        }