Java基础第六章一维数组及经典应用

一、数组

数组就是一个变量，只不过这个变量可以存储多个数据，但是这些数据必须是同一数据类型
数组是线性结构，在内存中开辟是连续的存储空间

数组的定义：

        //1.声明数组
        int[] scores; //定义一个int的数组变量，变量名为scores
        //2.初始化数组，开辟连续空间
        scores = new int[5]; //开辟5个int类型大小的空间
        
        /*      创建数组的其他方式：  
        int[] scores = new int[]{80,90,60,56}; 
        int[] scores = {80,90,60};*/
        
        //3.给数组赋值（存放数据）
        scores[0] = 80;
        scores[1] = 78;
        scores[2] = 85;
        scores[3] = 90;
        scores[4] = 95;
        //4、操作数据
        System.out.println(scores[4]);

数组直接赋值和动态赋值：

 //数组直接赋值和动态赋值
        //直接赋值
/*      int[] scores = new int[]{80,90,60,56};
        int[] scores = {80,90,60};
*/
        //动态赋值
        Scanner input = new Scanner(System.in);
        int[] scores = new int[5];//定义一个5个大小的数组
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入第" + (i + 1) + "个数");
            scores[i] = input.nextInt();
        }
        System.out.println("数组中的元素为：" + Arrays.toString(scores));

求平均值：

.length属性是获取数据的长度（大小）

	    //求平均值：scores.length属性是获取数据的长度（大小）
        Scanner input = new Scanner(System.in);
        int[] scores = new int[5];
        double sum = 0;
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入第" + (i + 1) + "个数""请输入第" + (i + 1) + "个数");
            scores[i] = input.nextInt();
            sum += scores[i];
        }
        System.out.println(sum/scores.length);

数组遍历

        //数组遍历
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
        //增强型for循环
        for (int score : scores) {
            System.out.println(score);
        }

数组案例一

        /*有一个数列：8，4，2，1，23，344，12
         循环输出数列的值
         求数列中所有数值的和
         猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数5 */
        Scanner input = new Scanner(System.in);
        int[] nums = {8, 4, 2, 1, 23, 344, 12};
        int sum = 0;
        for (int i : nums) {
            System.out.print(i + " ");
            sum += i;
        }
        System.out.println("\n数列中所有数值的和为：" + sum);
        System.out.print("请输入一个数：");
        int number = input.nextInt();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == number) {
                System.out.println("数列中包含此数：" + number);
            } else if (i == nums.length - 1) {
                System.out.println("数列中不包含此数：" + number);
            }
        }

求最大值

        //求最大值
        int[] nums = {85,45,90,34,88};
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i]>max){
                max =nums[i];
            }
        }
        System.out.println("最大值是："+max);

求最小值

        //求最小值
        int min = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] < min) {
                min = nums[i];
            }
        }
        System.out.println("最大值是：" + min);

插入

        //插入
        Scanner input = new Scanner(System.in);
        int[] nums = new int[6];
        nums[0] = 50;
        nums[1] = 40;
        nums[2] = 30;
        nums[3] = 20;
        nums[4] = 10;
        nums[5] = 0;

        System.out.println("请输入要插入的数： ");
        int insertNum = input.nextInt();
        System.out.println("请输入要插入的下标： ");
        int insertIndex = input.nextInt();
        for (int i = nums.length - 1; i > insertIndex; i--){
            nums[i] = nums[i - 1];
        }
        nums[insertIndex] = insertNum;
        System.out.println(Arrays.toString(nums));

删除

 //删除
        System.out.println("请输入要删除的下标： ");
        int deleteIndex = input.nextInt();
        for (int i = deleteIndex; i < nums.length - 1; i++) {
            nums[i] = nums[i + 1];
        }
        nums[nums.length - 1] = 0;
        System.out.println("after:" + Arrays.toString(nums));

冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法，常用于对数组进行排序。它的基本思想是通过相邻元素之间的比较和交换来逐步将最大（或最小）的元素移动到数组的末尾。

冒泡排序的具体步骤如下：

1. 从数组的第一个元素开始，比较相邻的两个元素。如果前一个元素大于后一个元素，则交换它们的位置，使较大的元素向后移动。
2. 继续比较下一个相邻的两个元素，重复上述步骤，直到达到倒数第二个元素。
3. 重复执行上述步骤，每次都将最大的元素移动到当前未排序部分的末尾。
4. 重复执行步骤1至步骤3，直到所有元素都排序完成。

下面是使用冒泡排序算法对一个整数数组进行升序排序的示例代码：

        //冒泡排序
        int[] nums = {60, 85, 99, 82, 63};
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length-i-1; j++) {
                int temp = 0;
                if (nums[j] > nums[j + 1]) {
                    temp =nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序："+ Arrays.toString(nums));

选择排序

选择排序（Selection Sort）是一种简单的排序算法，它的基本思想是每次从未排序的部分中选择最小（或最大）的元素，然后将其放到已排序部分的末尾。

选择排序的具体步骤如下：

1. 在未排序部分中，找到最小（或最大）的元素。
2. 将最小（或最大）的元素与未排序部分的第一个元素交换位置，将该元素放到已排序部分的末尾。
3. 重复执行步骤1和步骤2，直到所有元素都排序完成。

下面是使用选择排序算法对一个整数数组进行升序排序的示例代码：

//选择排序
        int[] arr = {60, 85, 99, 82, 63};
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; // 用来记录最小值的索引位置，默认值为i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
                }
            }
            // 交换当前索引 i 和最小值索引 minIndex 两处的值
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
            // 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
        }
        System.out.println("选择排序：" + Arrays.toString(arr));