花几千上万学习Java，真没必要！（二十八）

冒泡排序：

测试代码1：

public class BubbleSortAdvanced {  
	  
    /**  
     * 使用swapped标志检查数组是否已经是排序状态  
     *  
     * @param arr 需要排序的数组  
     */  
    public static void bubbleSort(int[] arr) {  
        if (arr == null || arr.length <= 1) {  
            return; // 如果数组为空或只有一个元素，则不需要排序  
        }  
        //用swapped布尔变量跟踪每一轮排序是否发生元素交换。
        boolean swapped;  
        for (int i = 0; i < arr.length - 1; i++) {  
            swapped = false; // 假设没有发生交换  
            for (int j = 0; j < arr.length - i - 1; j++) {  
                if (arr[j] > arr[j + 1]) {  
                    // 交换arr[j]和arr[j+1]  
                    int temp = arr[j];  
                    arr[j] = arr[j + 1];  
                    arr[j + 1] = temp;  
                   
                    swapped = true; // 标记发生了交换  
                }  
            }  
  
            // 如果没有发生交换，说明数组已经是有序的，可以提前退出  
            if (!swapped) {  
                break;  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        int[] arr = {64, 34, 25, 12, 22, 11, 90};  
        bubbleSort(arr);  
        System.out.println("Sorted array:");  
        for (int num : arr) {  
            System.out.print(num + " ");  
        }  
    }  
}

运行结果如下：

测试代码2：

package bubbleSorttest.com;
//使用泛型支持不同类型数组的冒泡排序，
//增加一个命令行接口指定是升序还是降序。
public class GenericBubbleSort {  
    public static void main(String[] args) {  
        // 对Integer数组进行升序排序  
        Integer[] intArray = {64, 34, 25, 12, 22, 11, 90};  
        bubbleSort(intArray, true); // 第三个参数为true表示升序  
        System.out.println("Sorted Integer array (ascending):");  
        printArray(intArray);  
  
        // 对String数组进行降序排序  
        String[] stringArray = {"banana", "apple", "orange", "mango"};  
        bubbleSort(stringArray, false); // 第三个参数为false表示降序  
        System.out.println("Sorted String array (descending):");  
        printArray(stringArray);  
    }  
    //bubbleSort 方法为使用泛型 <T extends Comparable<T>>，
    //可以对任何实现了 Comparable 接口的类型的数组进行排序。
    //布尔参数 ascending，可以控制排序的方向（升序或降序）。
    // 泛型冒泡排序
    static <T extends Comparable<T>> void bubbleSort(T[] arr, boolean ascending) {  
        int n = arr.length;  
        boolean swapped;  
        for (int i = 0; i < n - 1; i++) {  
            swapped = false;  
            for (int j = 0; j < n - i - 1; j++) {  
                int compareResult = arr[j].compareTo(arr[j + 1]);  
                if ((ascending && compareResult > 0) || (!ascending && compareResult < 0)) {  
                    // 交换元素  
                    T temp = arr[j];  
                    arr[j] = arr[j + 1];  
                    arr[j + 1] = temp;  
                    swapped = true;  
                }  
            }  
            // 如果没有发生交换，则提前结束  
            if (!swapped) break;  
        }  
    }  
  
    // 泛型打印数组方法  
    static <T> void printArray(T[] arr) {  
        for (T element : arr) {  
            System.out.print(element + " ");  
        }  
        System.out.println();  
    }  
}

 运行结果如下：

测试代码3：

package bubbleSorttest.com;
import java.util.Scanner;  
//创建一个类管理数组的排序，并在该类中添加方法读取输入、执行排序以及打印输出。
//BubbleSortManager 类封装冒泡排序的逻辑以及数组的输入输出操作。
//readArrayFromUser 方法是一个静态方法，用于读取一个指定大小的整数数组。
//bubbleSort 方法实现冒泡排序算法，printArray 方法用于打印数组的内容。
//main方法展示使用这个类读取用户输入的数组，执行排序，并打印排序前后的数组。
public class BubbleSortManager {  
    private int[] array;  
  
    // 构造函数，用于初始化数组  
    public BubbleSortManager(int[] array) {  
        this.array = array;  
    }  
  
    // 从用户那里读取数组（作为示例，这里简化处理，直接通过Scanner读取固定数量的整数）  
    public static int[] readArrayFromUser(Scanner scanner, int size) {  
        int[] array = new int[size];  
        System.out.println("请输入" + size + "个整数：");  
        for (int i = 0; i < size; i++) {  
            array[i] = scanner.nextInt();  
        }  
        return array;  
    }  
  
    // 冒泡排序方法  
    public void bubbleSort() {  
        boolean swapped;  
        for (int i = 0; i < array.length - 1; i++) {  
            swapped = false;  
            for (int j = 0; j < array.length - i - 1; 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;  
            }  
        }  
    }  
  
    // 打印数组的方法  
    public void printArray() {  
        for (int num : array) {  
            System.out.print(num + " ");  
        }  
        System.out.println();  
    }  
  
    // 主方法，用于演示类的使用  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        System.out.print("请输入数组的大小：");  
        int size = scanner.nextInt();  
        int[] array = readArrayFromUser(scanner, size);  
  
        BubbleSortManager manager = new BubbleSortManager(array);  
        System.out.println("原始数组：");  
        manager.printArray();  
  
        manager.bubbleSort();  
  
        System.out.println("排序后的数组：");  
        manager.printArray();  
  
        scanner.close();  
    }  
}

运行结果如下：

测试代码4：

创建一个运动员类：

package bubbleSorttest.com;
public class Athlete implements Comparable<Athlete> {  
    private String name;  
    private int ranking; // 用ranking代表运动员的排名或成绩  
  
    public Athlete(String name, int ranking) {  
        this.name = name;  
        this.ranking = ranking;  
    }  
  
  
    public void setName(String name) {
		this.name = name;
	}

	public void setRanking(int ranking) {
		this.ranking = ranking;
	}

	public String getName() {  
        return name;  
    }  
  
    public int getRanking() {  
        return ranking;  
    }  
  
    @Override  
    public int compareTo(Athlete other) {  
        return Integer.compare(this.ranking, other.ranking); // 按照排名进行比较  
    }  
  
    @Override  
    public String toString() {  
        return "Athlete{" +  
                "name='" + name + '\'' +  
                ", ranking=" + ranking +  
                '}';  
    }  
}

使用冒泡排序对运动员列表进行排序 :

import java.util.ArrayList;  
import java.util.List;  
  
public class BubbleSortDemo {  
  
    public static void main(String[] args) {  
        List<Athlete> athletes = new ArrayList<>();  
        athletes.add(new Athlete("Alice", 85));  
        athletes.add(new Athlete("Bob", 92));  
        athletes.add(new Athlete("Charlie", 78));  
        athletes.add(new Athlete("David", 88));  
  
        System.out.println("Original list:");  
        for (Athlete athlete : athletes) {  
            System.out.println(athlete);  
        }  
  
        bubbleSort(athletes);  
  
        System.out.println("\nSorted list:");  
        for (Athlete athlete : athletes) {  
            System.out.println(athlete);  
        }  
    }  
  
    // 使用冒泡排序对运动员列表进行排序  
    static void bubbleSort(List<Athlete> athletes) {  
        int n = athletes.size();  
        boolean swapped;  
        for (int i = 0; i < n - 1; i++) {  
            swapped = false;  
            for (int j = 0; j < n - i - 1; j++) {  
                if (athletes.get(j).compareTo(athletes.get(j + 1)) > 0) {  
                    // 交换运动员对象  
                    Athlete temp = athletes.get(j);  
                    athletes.set(j, athletes.get(j + 1));  
                    athletes.set(j + 1, temp);  
                    swapped = true;  
                }  
            }  
            // 如果没有发生交换，则列表已经有序，可以提前退出  
            if (!swapped) {  
                break;  
            }  
        }  
    }  
}

运行结果如下：