冒泡排序：
测试代码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;
}
}
}
}运行结果如下：
