数组与冒泡法排序

package array;
import java.util.Scanner;

public class BubbleSort{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 用户输入数组的长度
        System.out.print("请输入数组的长度: ");
        int length = scanner.nextInt();

        // 创建用户自定义数组
        int[] array = new int[length];

        // 用户输入数组的元素
        System.out.println("请输入数组的元素:");
        for (int i = 0; i < length; i++) {
            array[i] = scanner.nextInt();
        }
        scanner.close();
        // 打印原始数组
        System.out.println("原始数组:");
        printArray(array);

        // 对数组进行冒泡排序
        bubbleSort(array);

        // 打印排序后的数组
        System.out.println("排序后的数组:");
        printArray(array);
    }

    // 冒泡排序算法
    private static void bubbleSort(int[] array) {
        int n = array.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换 array[j] 和 array[j + 1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    swapped = true;
                }
            }
            // 如果在某一轮中没有发生交换，说明数组已排序完成
            if (!swapped) break;
        }
    }

    // 打印数组
    private static void printArray(int[] array) {
        for (int element : array) {
            System.out.print(element + " ");
        }
		/*
		 * int element : array 是 Java 中的增强 for 循环（也称为 "for-each" 循环）的语法，
		 * 用于遍历数组或集合中的元素。这种循环方式使得代码更加简洁和易读。 
		 * 具体来说，这个语法结构用于迭代 array 数组中的每一个元素，并将当前元素赋值给
		 * element 变量。
		 */
        System.out.println();
    }
}

注意：1.用户自定义方法使用以及冒泡法排序，一起复习

           2.巧妙利用swapped标记是否结束排序，此处与当初学习C时有区别

附：数组练习

package array;

import java.util.Arrays;

public class ArrayExercise02 {
    public static void main(String[] args) {
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100) + 1;
        }

        System.out.println("当前元素情况:");
        printArray(arr);

        int[] sortArr = Arrays.copyOf(arr, arr.length);
        bubbleSort(sortArr);

        System.out.println("排序后元素情况:");
        printArray(sortArr);

        double sum = 0;
        int max = arr[0];
        int maxIndex = 0;

        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
            if (arr[i] > max) {
                max = arr[i];
                maxIndex = i;
            }
        }

        System.out.println("最大值为：" + max + " 下标为：" + maxIndex);
        System.out.println("平均值为：" + (sum / arr.length));
    }

    public static void printArray(int[] array) {
        for (int element : array) {
            System.out.print(element + "\t");
        }
        System.out.println();
    }

    public static void bubbleSort(int[] array) {
        int n = array.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    swapped = true;
                }
            }
            if (!swapped) break;
        }
    }
}

注意：

        1.直接对原数组进行冒泡法排序会导致最大值下标错误输出

        2.直接使新数组arrSort[] = arr会导致两个数组名称指向同一个数组，这也是类似于C中的指针或者称为地址，赋地址，这是数组学习中要辩立的地方，同时也是JAVA语言中堆、栈概念的一个理解。再次一并记录

变化分析

1. 使用 Arrays.copyOf() 替换手动数组复制:

2. 提取打印数组的方法: 提取出一个 printArray 方法来打印数组，避免重复代码。

3. 简化求和和找最大值的循环: 在一个循环中完成求和和找最大值的操作，减少循环次数。

4. 这样做不仅使代码更简洁，还提高了代码的可读性和可维护性。