一维数组与二维数组，详解，内存解析，数组涉及的算法，二分查找法，杨光辉三角形，线性查找，冒泡排序，数组的赋值操作，反转

于 2021-10-18 16:45:38 发布
阅读量218 收藏
点赞数 1
分类专栏： Java基础 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62678864/article/details/120829486
版权

一维数组的概述

数组的理解:数组是多个相同类型的数据按照一定顺序排列的集合，并使用一个名字命名，并且通过编号的方式对这些数据进行统一的管理

  • 2.数组的相关概念 》数组名 》元素 》角标，下标，索引 》数组的长度:元素的个数

    3。数组的特点：数组是有序排列的 4.数组属于引用数据类型变量：数组的元素可以是基本数据类型，也可以是引用数据类型

    • 5.创建数组对象时会在内存开辟一块连续的空间 数组的长度一旦确定就不能修改 *

      • 一维数组的使用 ① 一维数组的生命和初始化 ②如何调用数组指定位置的元素 ③如何获取数组的长度 ④如何遍历数组 ⑤数组元素的默认初始化值

    public static void main(String[] args) {
        // 数组元素默认初始化值
        /*
         * 》数组元素时整型 0 >数组元素浮点型:0.0 》数组元素是char型：0 boolean :false
         * 
         * 
         * 数组元素是引用数据类型时：null 不是"null"
         */
        int[] arr = new int[4];
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
​
        // 一维数组的声明和初始化
        // 静态初始化 数组初始化和数组元素的复制操作
​
        int[] ids;// 声明
        ids = new int[] { 1001, 1002, 1003, 1004 };
        // 动态初始化: 数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];
        // 总结：一旦初始化之后长度就不能改变了
        // 2.如何调用数组指定位置的元素:通过角标的方式调用
        // 数组的角标(索引)从0开始的，到数组的长度-1结束
        names[0] = "张晗";
        names[1] = "李三";
        names[2] = "李三";
        names[3] = "李三";
        names[4] = "李三";
        for (String string : names) {
            System.out.println(string);
        }
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
            System.out.println(names[i].charAt(0));
        }
        // 3获取数组长度
        System.out.println(names.length);
    }
}

数组的内存解析

数组的内存解析

  • 栈内存(stack)存储的时局部变量

  • 堆内存(heap) *存储的时new出来的结构：对象，数组 *方法区: *常量池 静态域

  •  

public class ArrayTest2 {
​
    public static void main(String[] args) {
        //创建Scanner对象，从键盘输入五个成绩
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入学生个数：");
        int sum = scan.nextInt();
        int[] arr = new int[sum];
        //int[] score = new int[sum];
        System.out.println("请输入"+sum+"个学生成绩");
        
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scan.nextInt();//从键盘获取成绩并且赋值给数组 动态赋值
            }
        //获取数组里面的最大值也就是最高分
        int maxScore = 0;
        for (int i = 0; i < arr.length; i++) {
            if(maxScore<=arr[i]){
                maxScore = arr[i];//冒泡排序
            }
        }
        System.out.println("成绩的最大值时:"+maxScore);
        char ch = ' ';
        for (int i = 0; i < arr.length; i++) {
            if(maxScore-arr[i]<=10){
                ch = 'A';
            }else if(maxScore-arr[i]<=20){
                ch='B';
            }else if(maxScore-arr[i]<=30){
                ch='C';
            }else{
                ch='D';
            }
            System.out.println("student"+arr[i]+"成绩为"+arr[i]+"等级为"+ch);
        }
    }
    
}
​

二维数组

二维数组

  • 数组属于引用数据类型

  • 数组的元素也可以是引用数据类型

  • 一个个一维数组AA的元素如果还是一个一维数组类型的，则，此数组A称为二维数组 *二内层元素:arr0等 *数组元素的默认初始化值 *针对于初始化方式一:比如:int arr= new int4; *外层元素初始化值为：地址值 *内层元素初始化值为:与一维数组初始化情况相同 * *针对于初始化方式二:比如:int arr = new int4;

  • 外层元素的初始化值为：地址值

  • 内层元素初始化值为:与一维数组初始化情况相同 * *对于动态初始化二：比如：int arr= new int4;

  • 外层元素初始化值为:null;

  • 内层元素初始化值为；报错NullPointerException;空指针异常 * *二维数组的默认初始化值 *规定:二维数组分为外层数组的元素，内层数组的元素 *int arr = new int4; *外层元素:arr[0],arr[1]等 *

  • @author zhanghan *

public class ArrayTest3 {
​
    public static void main(String[] args) {
        //二维数组的声明与初始化
        //静态初始化1
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化二
        String[][] arr2 = new String[5][3];
        //动态初始化2
        String[][] arr3 = new String[5][];
        //如何调用二维数组
        System.out.println(arr1[0][0]);
        arr3[1]=new String[]{"张三","李四"};
        System.out.println(arr3[1][1]);
        
        //遍历二维数组
        for (int i = 0; i < arr1.length; i++) {
                for (int j = 0; j < arr1[i].length; j++) {
                    System.out.println(arr1[i][j]);
                }
        }
        
        
    }
}
​

常见算法题

数组的排序算法

 

 

杨辉三角形

/**

  • 使用二维数组打印一个10行的杨辉三角形

  • @author 张晗 * *提示： *1.第一行有1个元素，第n行有n个元素 *2.每一行的第一个元素和最后一个元素都是1 *3.从第三行开始，对u非第一个元素和最后一个元素 *yanghuii = yanghuii-1 + yanghuii-1; */ public class ArrayTest4 {

public static void main(String[] args) {
    //声明并初始化二维数组
    int[][] yanghui = new int[10][];
    //给数组的元素赋值
    for (int i = 0; i < yanghui.length; i++) {
        //每行的的元素个数时 i 个，i初始值为0所以要加1
        yanghui[i]=new int[i+1];
        //给首末元素赋值
        yanghui[i][0]=yanghui[i][i]=1;
        for (int j = 1; j < yanghui[i].length-1; j++) {
            yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
        }
    }
        
    //遍历二维数组
    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();
    }
    }

}

算法的考察

/**
 * 算法的考察
 * 求数值型属猪元素中的最大值，最小值，平均数，总和等
 * 
 * 定义一个int型的一维数组，包含十个元素，分别赋一些随机整数出来
 * 然后求出所有元素的最大值，最小值，和值，品均值，并输出出来
 * ：要求：所有随机数都是两位数
 * [10,99]
 * 公式:(int)(Math.random() * (99 - 10 + 1) + 10)
 * @author 张晗
 *
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
            
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }
        System.out.println();
        //求数组元素的最大值
        int maxValue = 0;
        for (int i = 0; i < arr.length; i++) {
            if(maxValue<arr[i]){
                maxValue = arr[i];
            }
        }
        //输出最大值
        System.out.println("最大值为:"+maxValue);
        
        //求元素最小值
        int minValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(minValue>arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值为:"+minValue);
        
        //求数组元素的总共和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("数组的总和为:"+sum);
        
        
        
    }
}
​

算法的考查：数组的复制、反转、查找(线性查找、二分法查找)

/**
 *  * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * @author zhanghan
 *
 */
public class ArrayTest2 {
        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];
            }
            System.out.println("反转前:"+Arrays.toString(arr1));
            
            //数组的反转
            //方法一：
            for (int i = 0; i < arr1.length/2; i++) {
                String temp = arr1[i];
                arr1[i]=arr1[arr1.length-1-i];
                arr1[arr1.length-1-i] = temp;
            }
            //方法二：
//          for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//              String temp = arr[i];
//              arr[i] = arr[j];
//              arr[j] = temp;
//          }
            
            for (int i = 0; i < arr1.length; i++) {
                System.out.print(arr1[i]);
            }
            
            //二分查找法
            //前提：所要查找的数组必须有序
            int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
            
            int dest1 = -34;
            int head = 0;//初始索引
            int end = arr2.length-1;//初始的末索引
            boolean isFlag = true;
            while(head<=end){
                int middle = (head+end)/2;
                if(dest1 == arr2[middle]){
                    System.out.println("找到了指定的元素,位置为："+middle);
                    isFlag=false;
                    break;
                }else if(arr2[middle]>dest1){
                    end = middle -1;
                    
                }else{
                    head = middle+1;
                }
            }
            
            
            
        }
}
​

冒泡排序

package com.zhanghan.ag;

import java.util.Arrays;

/**

  • 冒泡排序实现

  • @author 张晗 * */ public class BubbleSortTest {

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; i++) {
        for (int j = 0; j < arr.length-1-i; j++) {
            if(arr[j]<arr[j+1]){
                 int temp = arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
            }
        }
    }
    System.out.println(Arrays.toString(arr));
}

}

张晗11122211
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值