4.一维数组，二维数组，算法。

最新推荐文章于 2023-09-05 09:24:36 发布

程序员阿磊

最新推荐文章于 2023-09-05 09:24:36 发布

阅读量288

点赞数 1

分类专栏： JAVA # 1.JAVA基础文章标签： java jvm 开发语言算法 intellij-idea

本文链接：https://blog.csdn.net/m0_62112791/article/details/125879843

版权

JAVA 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

1.JAVA基础

5 篇文章 0 订阅

订阅专栏

复习

数据类型

自定类

注解

枚举

Array(数组)

String(字符串)

double(双精度浮点型)

long(长整型)

float(单精度浮点型)

int(整型)

char(字符)

short(短整型)

byte(字节)

boolean(布尔)

引用数据类型

基本数据类型

java数据类型

1.一维数组

顾名思义一组的数

以前学的都是一个数，有时候要用到一系列数如何做？

对比学习和记忆语句：只能是一条，而有些是一条语句是表示不完整的，所以语句有了简单语句和复合语句，一句话能表示的是简单语句；多句话组成了逻辑上的一句话，称为复合语句。

变量，只能是一个值，但是有时候想表示多个值怎么办呢？数组就是在逻辑上把一系列数据表示为一个数。

3w1h 3:what why where 1 how

1.数组定义语法

// 变量定义语法模板  复习
type varName [=value];        // 数据类型 变量名 [=变量值];
int i = 10;

数组类型 变量名 = 数组的值;
// 比如我想表示一系列整数
// array数组：引用数据类型---引用变量
数据类型[] 数组名 = new  数据类型[大小]  ;
int[5] datas = {1,2,3,4,5};

int[] datas2 = new int[5];

取值和改值

// 数组中的索引值是从0开始的
// 定义一个数组   表示 1，2，3，4，5
int[] datas = {1,2,3,4,5};
System.out.println(datas); // 为什么没输出1 2 3 4 5 ，而是输出：[I@15db9742
for(int i = 0 ; i < datas.length ; i++){
     System.out.println(datas[i]);
}
System.out.println("-------");
// 取值
System.out.println(datas[3]);    // 4
// 改值
datas[3] = 12;
System.out.println(datas[3]);    // 12

数组使用过程中最常见的错误：数组越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
        at day08.demo01.main(demo01.java:9)

获取数组长度：数组的引用变量.length
代码案例：

package day08;
import java.util.Scanner;
public class demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入多少个数：");
        int num = scanner.nextInt();
        int[] ds = new int[num];
        // 裴波拉契 1 1 2 3 5 8 13 21 ...
        // 第一种 for循环
        ds[0] = 1;
        ds[1] = 1;
        for(int i = 2 ; i < ds.length; i++){
            ds[i]=ds[i-1]+ds[i-2];
        }
        for(int i = 0 ; i < ds.length ; i++){
            System.out.println(ds[i]);
        }

        // 第二种 for循环    foreach
        System.out.println("==========");
        for(int i : ds){    // i 不是数组索引，而是数组元素
            System.out.println(i);
        }
    }
}

foreach循环

for(数据类型  迭代变量 : 被迭代的数据引用变量){
    // 循环操作
}

学会了
数组定义数组访问数组取长度 foreach

2.数组实现经典案例:

两个数组，两层循环实现
1.整体思维逻辑实现案例

package day08;
import java.util.Scanner;
public class demo03 {
    public static void main(String[] args) {
        //Scanner scanner = new Scanner(System.in);
        //System.out.println("");


        int[] a1 = {1,2,3,4,5};
        int[] a2 = new int[5];
        int shu = 0;
        // 循环几轮
        for(int j=0;j<4;j++){
            System.out.println("这是第"+(j+1)+"轮\n");
            // 在a2中保留不是3的倍数的数
            for(int i = 0 ; i < 5; i++){
                if(a1[i] == 0){
                    continue;
                }
                shu++;
                if(shu % 3 == 0){
                    System.out.println("数到了3的倍数"+shu);
                }else{
                    a2[i]=a1[i];
                    System.out.println("不是3的倍数"+shu);
                }
            }
            // 将a2中的数据赋值给a1
            for(int i = 0 ; i< 5 ; i++){
                a1[i] = a2[i];
            }
            System.out.println("-------a2-------");
            for(int i : a2){
                System.out.println(i);
            }
            System.out.println("-------a1-------");
            for(int i : a1){
                System.out.println(i);
            }
            for(int i=0;i<5;i++){
                a2[i] = 0;
            }
            System.out.println("========a2=====");
            for(int i : a2){
                System.out.println(i);
            }
            System.out.println("数报到："+shu+"\n\n");
        }


        for(int i : a1){
            if(i == 0){
                continue;
            }
            System.out.println("被剩下的是："+i);
        }
    }
}

2.两个数组实现的最终版

package day08;
import java.util.Scanner;
public class demo04 {
    public static void main(String[] args) {
        // 思路注解
        // 1。设计两个数组 第一个数组用来报数，
        //    第二个数组用来暂时存放不是3的倍数的数据
        //    等一轮报数完成后要将第二个数组的数据逐一赋值给第一个数组
        // 2.定义一个报数变量 将来它要不断++，
        //    之后用他来判断是不是3的倍数
        // 3.当报数数组a1中的数是0的时候，要跳过报数
        // 4.当报数数组a1中，只有一个数的时候结束报数

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入参与游戏的人数：");
        int num = scanner.nextInt();

        int[] a1 = new int[num];
        // 为数组的每个元素赋值
        for(int i=0; i<num ; i++){
            a1[i] = i+1;
        }
        int[] a2 = new int[num];

        int shu = 0;
        // 控制轮 无法确定
        while(true){
            int nums = 0;   // 假设
            for(int i : a1){
                if(i != 0){
                    nums++;       // 假设
                }
            }
            if(nums == 1){
                // 表示游戏要结束了
                break;
            }

            // 每一轮中还在的数据 进行报数
            for(int i = 0 ; i < a1.length; i++){
                if(a1[i] == 0){
                    continue;
                }
                shu++;
                if(shu % 3 != 0){
                    a2[i] = a1[i];
                }
            }

            // 当一轮报数结束时 把a2的数据赋值给a1
            for(int i = 0 ; i <a2.length; i++){
                a1[i] = a2[i];
            }

            // 清空a2中所有的数据
            for(int i = 0; i< a2.length; i++){
                a2[i] = 0;
            }
        }

        for (int i : a1) {
            if(i == 0){
                continue;
            } 
            System.out.println("被剩下的数是："+i);
        }
    }    
}

解决问题的经验与方法：死去活来法，假设修正法，降阶法

3.数组实现经典案例:

一个数组,一层循环实现

package day09;
import java.util.Scanner;
public class demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要参加游戏的小孩人数：");
        int num = scanner.nextInt();

        int[] d = new int[num];
        // 为数组的每个元素赋值
        for(int i=0; i<num ; i++){
            d[i] = i+1;
        }
        //int[] d = {1,2,3,4,5,6,7,8,9,10};

        int chuqu = 0;

        int shu = 0;

        for(int i=0 ; true ; i++){
            /*System.out.println(d[i]);
            if(i == 9){
                i=-1;
            }*/
            // ↑ 与 ↓ 代码的执行效果是一模一样的
            //System.out.println(d[i%d.length]); 

            if(chuqu == d.length -1){
                break;
            }
            if(d[i%d.length] == 0){
                continue;
            }
            shu++;
            if(shu%3 == 0){
                d[i%d.length] = 0;
                chuqu++;
            }           
        }
        for (int i : d) {
            if(i != 0){
                System.out.println("被剩下的数是："+i);
            }
        }
    }
}

数组一旦初始化后不能再改变长度，只能改变数组中的元素，数组中的元素是可以重复的。

2.二维数组

二维数组：本质是一维数组嵌套了一维数组

语法定义

// 数据类型[][] 变量名 [=值];
// 定义一个3*4的二维数组，共12个元素
int [][] d = {{1,2,3,4},{3,45,6,5},{3,4,55,67}};

// 取值：取二维数组中的55这个元素
System.out.println(d[2][2]);    //55

// 改值:将45修改为4
d[1][1] = 4;
System.out.println(d[1][1]);    // 4

//如何将{3,4,55,67}一次修改为{1,1,1,1}
d[2] = new int[]{1,1,1,1};
System.out.println(d[2][0]);
System.out.println(d[2][1]);
System.out.println(d[2][2]);
System.out.println(d[2][3]);

二维数组练习：计算总成绩之和

package day09;
import java.util.Scanner;
public class demo3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 初始化一个3*5的二维数组
        // int 初始化的数组默认元素值是0
        int[][] scores = new int[3][5];

        // 方法1：输出语句，输入的成绩各自采用两层循环
        for (int i = 0; i < scores.length; i++) {
            System.out.println("=======第"+(i+1)+"班======");
            for(int j = 0; j < scores[i].length; j++){
                System.out.println("请输入第"+(j+1)+"个学生的成绩:");
                scores[i][j] = scanner.nextInt();
            }
        }
        // 3个班级  循环3次
        for(int i = 0 ; i < scores.length ; i++){
            int banji = 0;
            // 5个学员  循环5次
            for(int j = 0 ; j < scores[i].length ; j++){
                banji += scores[i][j];
            }
            System.out.println("第"+(i+1)+"个班总成绩："+banji);
        }

        // 方法二：输出语句和输入的成绩，用同一个循环
        // 3个班级  循环3次
        for(int i = 0 ; i < scores.length ; i++){
            System.out.println("=======第"+(i+1)+"班======");
            int banji = 0;
            // 5个学员  循环5次
            for(int j = 0 ; j < scores[i].length ; j++){
                System.out.println("请输入第"+(j+1)+"个学生的成绩:");
                scores[i][j] = scanner.nextInt();
                banji += scores[i][j];                
            }
            System.out.println("第"+(i+1)+"个班总成绩："+banji);
        }

        // 方法3：输出语句采用一层for循环
        for (int i = 0; i < 15; i++) {
            int ban = i / 5;
            int ming = i % 5;
            System.out.println("请输入第"+(ban+1)+"班的第"+(ming+1)+"名学生：");
            scores[ban][ming] = scanner.nextInt();
        }
        for(int i =0; i < scores.length ; i++){
            int sum = 0;
            for(int j = 0; j < scores[i].length ; j++){
                sum += scores[i][j];
            }
            System.out.println("第"+(i+1)+"班的总成绩是："+sum);
        }
    }
}

3.排序算法

参考：十种排序算法_coolwriter的博客-CSDN博客_排序算法

堆排序

简单选择排序

希尔排序

直接插入排序

快速排序(快速法)

冒泡排序(冒泡法)

基数排序

归并排序

选择排序

插入排序

交换排序

外部排序法

内部排序法

计算机排序算法

3.1、冒泡排序

排序是将一系列数据按照从大到小或者从小到大的规律进行排列。

1.冒泡排序代码案例

package day09;
public class demo4 {
    public static void main(String[] args) {
        /**
         * 对数据进行多轮的查找   最值    将最值移动到数据的一侧
         * 每一轮仅能将一个最值确定在合适的一侧   通过比较  比较次数(待确定的数-1)次
         * 通过多轮完成所有最值  确定在合适位置   有(所有排序数-1)轮
         * 
         * 共比较了 1+2+3+。。。n次   公式：(n-1)*n/2
         * 
         * 最坏的 交换次数为(n-1)*n/2
         * 
         * 平均时间复杂度    O(n²)
         * 
         * 空间复杂度    O(1)
         * 
         */
        int[] d = {3,4,56,7,8,3,4,5};

        for(int j = 0 ; j < d.length ; j++){
            // 编写算法代码，完成排序
            for(int i = 0 ; i < d.length-1 ; i++){
                // 判断两数大小
                if(d[i] > d[i+1]){
                    // 第一种判断比较：借助temp第三个变量
                    // int temp = d[i];
                    // d[i] = d[i+1];
                    // d[i+1] = temp;

                    // 第二种判断比较：使用运算符
                    // d[i] = d[i]+d[i+1];
                    // d[i+1] = d[i]-d[i+1];
                    // d[i] = d[i]-d[i+1];

                    // 第三种判断比较：使用亦或法
                    d[i] = d[i]^d[i+1];
                    d[i+1] = d[i]^d[i+1];
                    d[i] = d[i]^d[i+1];
                }
            }
        }
        System.out.println("-----------");

        for (int i : d) {
            System.out.println(i);
        }
    }
}

2.冒泡排序代码案例优化：假设修正法(假设一个数的下标位置)
优点：减少了比较次数,案例同上

package day09;
public class demo6 {   
    public static void main(String[] args) {
        int[] d = {3,4,56,7,8,3,4,5};

        // 编写算法代码，完成排序
        for(int j = 0 ; j < d.length-1 ; j++){
            int maxIndex = 0;   // 假设最大的数在第一个位置
            for(int i = 1 ; i < d.length-j ; i++){
                // 判断两数大小
                if(d[maxIndex] < d[i]){
                    maxIndex = i;   // 修正  最大数所在的位置
                }
            }
            int temp = d[maxIndex];  // 是所有数中最大数所在的位置
            d[maxIndex] = d[d.length-1-j];
            d[d.length-1-j] = temp;
        }        
        System.out.println("-----------");

        for (int i : d) {
            System.out.println(i);
        }
    }
}

3.2、插入排序

package day10;
public class demo02 {
    /**
     * 插入排序法
     * 
     * 思路：数组被看作两部分，
     *      已排序和待排序，
     *      总是在用待排序数中的第一个数到已排序数中找合适的位置
     *      将待排序的数插入到此位置
     * 
     * @param args
     */
    public static void main(String[] args) {

        int[] datas = {2,3,4,6,92,46,7,3,2,8};
        //int paiDao = 1;
        int temp;

        for(int paiDao = 1; paiDao < datas.length ; paiDao++){
            // 找即将排的数在已排序中的位置
            // 当排序数多的时候要循环找合适的位置
            for (int i = 0; i < paiDao; i++) {
                if(datas[paiDao] < datas[i]){
                    // datas[paiDao] 要放在 datas[i]前面
                    // 通过循环移动的方式
                    temp = datas[paiDao];

                    for(int j = paiDao; j>i;j--){
                        datas[j] = datas[j-1];
                    }
                    datas[i] = temp;
                    break;
                }
            }
        }

        for (int i : datas) {
            System.out.println(i);
        }
    }
}

4.数组拷贝

System.arraycopy(src, srcPos, dest, destPos, length); src 表示源数组 srcPos 表示源数组开始的位置 dest 表示目标数组 destPos 表示目标数组的开始位置 length 表示连续拷贝多少个数据

public class demo03 {
    /**
     * 拷贝数组
     * @param args
     */
    public static void main(String[] args) {
        int[] datas = {2,33,5,67,1};
        int[] xiao = new int[3];

        // 我想将33,5,67的数据放到xiao的数组中
        // for (int i = 0; i < xiao.length; i++) {
        //     xiao[i] = datas[i+1];
        // }

        // ↑ 和 ↓ 代码功能一样
        System.arraycopy(datas, 1, xiao, 0, xiao.length);

        for (int i : xiao) {
            System.out.println(i);
        }         
    }
}

5.数组工具类实用方法

学习参考网址：
Java数组复制（拷贝）的4种方法_命殿的博客-CSDN博客_java复制数组

5.1、Arrays.copyOf(original, newLength) 从original源数组创建一个长度为 newLength 新数组，数组不需要手动创建数组中的数据就是源数组中从头到指定newLength个数的数

import java.util.Arrays;
public class demo04 {
    public static void main(String[] args) {
        // Arrays 工具类实用方法
        int[] datas = {3,4,57,8,2};
        Arrays.copyOf(datas, 3);

        for (int i : datas) {
            System.out.println(i);
        }
    }
}

5.2、Arrays.copyOfRange(original, from, to) 从 original 数组中，创建一个范围型数组，从源数组中from位置到源数组中to位置，特别说明to是开区间，不包含to 包含 from 位置的数

import java.util.Arrays;
public class demo05 {
    public static void main(String[] args) {
        int[] datas = {3,4,7,23,4};
        int[] xiao = Arrays.copyOfRange(datas, 1, 3);
        for (int i : xiao) {
            System.out.println(i);
        }
    }
}

5.3、Arrays.sort(datas) 快排array数组

public class demo06 {
    public static void main(String[] args) {
        int[] datas = {3,4,7,23,4};

        // 排序
        Arrays.sort(datas);

        for (int i : datas) {
            System.out.println(i);
        }
    }
}

5.4、Arrays.binarySearch(array, val); 在array数组中快速二分查找 val 这个值，查出它的值得下标位置，前提是array从小到大有序

import java.util.Arrays;
public class demo07 {
    public static void main(String[] args) {
        int[] datas = {3,4,7,23,4};
        // 二分查找：前提是先有序排列，从小到大
        Arrays.sort(datas);
        for (int i : datas) {
            System.out.print(i+"  ");
        }
        System.out.println();

        // 快找  二分查找:二分快速查找必须是有序数组
        int weizhi =  Arrays.binarySearch(datas, 23);

        System.out.println(weizhi);
    }
}

5.5、Arrays.fill(array, val) 使用val值填充array数组

public class demo08 {
    public static void main(String[] args) {
        int[] datas = new int[5];
        Arrays.fill(datas, 2);
        for (int i : datas) {
            System.out.println(i);
        }
    }
}

5.6、Arrays.toString() 转换为字符串

import java.util.Arrays;
public class demo09 {
    public static void main(String[] args) {
        int[] datas = {2,4,76,3,8};
        System.out.println(Arrays.toString(datas));
    }
}