• 第五章：数组、排序和查找

    我亦无他 唯手熟尔

    化繁为简，先死后活

    一、介绍

    1.定义：

            引用数据类型，用来存储统一类型的数据

    二、数组的使用

    1.动态初始化：

            数据类型 数组名[] = new 数据类型[大小]  ==  数据类型[] 数组名 = new 数据类型[大小]（推荐写法）

    案例：循环输入5个数，保存到double数组

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         double[] arr = new double[5];
    7.         for (int i = 0; i < arr.length; i++) {
    8.             arr[i] = sc.nextDouble();
    9.         }
    10.         for (int i = 0; i < arr.length; i++) {
    11.             System.out.print(arr[i]+"\t");
    12.         }
    13.     }
    14. }

    2.动态初始化：

            先声明数组，再分配数组空间        数据类型[]  数组名；  数组名 = new 数据类型[大小]

            int[] a ;  a = new int[5]  等价于   int a[]; a =new int[5];

    3.静态初始化：

            数据类型 数组名[] = {数值} 等价于  数据类型[] 数组名 = {数值}          开发中用的不多

    4.注意事项：

    • 数组一定要保证数据类型的相同性，但是也可以保证小转大哦，double[] a = {100,1,31,100.1};
    • 数组里面可以放任何数据，但是要保证数据的同一性
    • 数组没有赋值是有默认值的，数组下标0开始

    5.案例：

            1.创建char类型数组，放置26个字符A-Z，并输出；

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         char[] arr = new char[26];
    4.         for (int i = 0; i < arr.length; i++) {
    5.             arr[i] = (char) ('A' + i);
    6.         }
    7.         for (int i = 0; i < arr.length; i++) {
    8.             System.out.print(arr[i]+"\t");
    9.         }
    10.     }
    11. }

            2.求出一个数组的最大值，并求到其下标

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[] arr = {4, -1, 9, 10, 23};
    4.         int max = 0, index = 0;
    5.         for (int i = 0; i < arr.length; i++) {
    6.             if (arr[i]>=max){
    7.                 max = arr[i];
    8.                 index = i;
    9.             }
    10.         }
    11.         System.out.println("index:"+index+" max: "+max);
    12.     }
    13. }

    三、数组赋值的机制

    1.定义：       

            数组的默认是一个引用数据类型，赋值的是一个地址。

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[] arr1 = {1,2,3};
    4.         int[] arr2 = arr1; //arr2的变化会影响arr1
    5.         arr2[2] = 10;
    6.         for (int i = 0; i < arr1.length; i++) {
    7.             System.out.println(arr1[i]); // 1 2 10
    8.         }
    9.     }
    10. }

    2.值传递 和 引用传递 的区别：

            

     3.数组拷贝：

            将int[] arr1 = {10,20,30} 拷贝到 arr2数组中。要求数据空间独立

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[] arr1 = {10, 20, 30};
    4.         int[] arr2 = new int[arr1.length];
    5.         for (int i = 0; i < arr1.length; i++) {
    6.             arr2[i] = arr1[i];
    7.         }
    8.         for (int i = 0; i < arr1.length; i++) {
    9.             System.out.print("arr1: "+ arr1[i]+'\t');
    10.             System.out.print("arr2: "+ arr2[i]+'\t');
    11.         }
    12.     }
    13. }

    4.数组的翻转：

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         //思路，新数组的长度最后一位值为后数组的第一位
    4.         int[] arr1 = {11, 22, 33, 44, 55, 66};
    5.         int[] arr2 = new int[arr1.length];
    6.         for (int i = 0; i < arr1.length; i++) {
    7.             arr2[arr1.length-1-i] = arr1[i];
    8.         }
    9.         for (int i = 0; i < arr1.length; i++) {
    10.             System.out.println(arr2[i]+"");
    11.         }
    12.     }
    13. }

    5.数组的添加：

            案例：用户可以自行决定是否添加

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         int[] arr1 = {}, arr2 = {};
    7.         do {
    8.             arr2 = new int[arr1.length + 1];
    9.             for (int i = 0; i < arr1.length; i++) {
    10.                 arr2[i] = arr1[i];
    11.             }
    12.             System.out.println("please input int:");
    13.             arr2[arr1.length] = sc.nextInt();
    14.             arr1 = arr2;
    15.             System.out.println("continue?please input yes/no:");
    16.             if (sc.next().equals("no")) break;
    17.         } while (true);
    18.         for (int i = 0; i < arr1.length; i++) {
    19.             System.out.print(arr1[i] + "\t");
    20.         }
    21.     }
    22. }

    四、数组排序

    1.冒泡排序：

    定义：一个一个往上走；        

    总结：5个数据进行4次排序(外层)，每一次排序确定一个元素的位置，前面的数大于后面的数进行交换，每一次少一个排序

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[] arr = {24, 69, 80, 57, 13, 200};
    4.         int temp = 0;
    5.         for (int i = 0; i < arr.length - 1; i++) {
    6.             for (int j = 0; j < arr.length - 1 - i; j++) {
    7.                 if (arr[j] > arr[j + 1]) {
    8.                     temp = arr[j + 1];
    9.                     arr[j + 1] = arr[j];
    10.                     arr[j] = temp;
    11.                 }
    12.             }
    13.         }
    14.         for (int i = 0; i < arr.length; i++) {
    15.             System.out.println(arr[i]);
    16.         }
    17.     }
    18. }

     2.查找

            案例1：顺序查找：

    1. import java.util.*;
    2.  
    3. public class Hello {
    4.     public static void main(String[] args) {
    5.         Scanner sc = new Scanner(System.in);
    6.         String[] names = {"pear", "apple", "banana", "tomato", "grape"};
    7.         System.out.println("please input fruit name: ");
    8.         String name = sc.next();
    9.         boolean flag = false;
    10.         for (int i = 0; i < names.length; i++) {
    11.             if (name.equals(names[i])) {
    12.                 flag = !flag;
    13.                 System.out.println("suecess!!!,index: " + i);
    14.             }
    15.         }
    16.         if (!flag) System.out.println("faith,not found");
    17.     }
    18. }

            案例2：二分查找（高级编程的时候讲）

    五、二维数组

    1.动态初始化：

            语法：类型[][]  数组名 = new 类型[大小][大小]

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[][] arr = new int[2][3];
    4.         arr[1][1] = 8;
    5.         for (int i = 0; i < arr.length; i++) {
    6.             for (int j = 0; j < arr[i].length; j++) {
    7.                 System.out.print(arr[i][j]+" ");
    8.             }
    9.             System.out.println();
    10.         }
    11.     }
    12. }

     2.静态初始化：

            定义：int[][] arr ={{0,0,0},{0,8,0}}

    3.列不确定声明：

            定义：int[][] arr = new int[3][]，arr[i] = new int[];

    六、二维数组的遍历

    案例1：遍历数组并求和：

    1. public class Hello {
    2.     public static void main(String[] args) {
    3.         int[][] arr ={{4,6},{1,4,5,7},{-2}};
    4.         int sum = 0;
    5.         for (int i = 0; i < arr.length; i++) {
    6.             for (int j = 0; j < arr[i].length; j++) {
    7.                 System.out.print(arr[i][j]+" ");
    8.                 sum+=arr[i][j];
    9.             }
    10.             System.out.println();
    11.         }
    12.         System.out.println("sum: "+sum);
    13.     }
    14. }

    案例2：杨辉三角：

           注意：第三行开始有： arr[i][j] = arr[i-1][j-1] + arr[i-1][j]   (自己写的很6啊)

    1. public class Hello {                                          //1
    2.     public static void main(String[] args) {                  //1 1
    3.         int[][] arr = new int[10][];                          //1 2 1
    4.         for (int i = 0; i < arr.length; i++) {                //1 3 3 1
    5.             arr[i] = new int[i + 1]; //开辟空间很六啊          //1 4 6 4 1
    6.             for (int j = 0; j < arr[i].length; j++) {         //1 5 10 10 5 1
    7.                 //第三行开始有： arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
    8.                 if (i == j || j == 0) {
    9.                     arr[i][j] = 1;
    10.                 }else{
    11.                     arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
    12.                 }
    13.                 System.out.print(arr[i][j] + " ");
    14.             }
    15.             System.out.println();
    16.         }
    17.     }
    18. }

     3.细节：       

            定义：二维数组声明   int[][] y(推荐) 或者  int[] y[] 或者  int y[][]

            二维数组是由一维数组构成

    注意：int[] x,y[]; ===>x为一维数组，y为二维数组；

    七、课后作业

    好好理解上面的代码

  • 相关阅读:
    scikit-learn保姆级入门教程
    Leetcode周赛365补题（3 / 3）
    【Linux】OS和进程概念
    从零开始-与大语言模型对话学技术-gradio篇（4）
    MySQL中find_in_set()函数用法详解
    前端框架Vue学习 ——（四）Axios
    NVIDIA 7th SkyHackathon（八）使用 Flask 与 Vue 开发 Web
    从白手起家到人尽皆知，他的大佬程序员之路是怎样走向成功的？
    《中华人民共和国网络安全法》
    升级 MDK 5.37 后的问题处理: AC6编译选项, printf, 重启失效等
  • 原文地址：https://blog.csdn.net/m0_61927991/article/details/126829131