排序算法

冒泡排序

算法介绍

冒泡排序（Bubble Sort），它重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置。这个过程会将每次遍历中最大（或最小）的未排序元素“冒泡”到列表的末尾。遍历列表的工作重复进行直到没有需要交换的元素为止，这意味着列表已经排序完成。

算法逻辑

1. 从数组的第一个元素开始，依次比较相邻的两个元素。
2. 如果前一个元素大于后一个元素，则交换它们的位置（升序排序时）。
3. 每次遍历会将当前未排序部分中最大的元素“冒泡”到正确的位置（即末尾）。
4. 重复上述过程，直到整个数组有序。

文字示例（升序）

原始数组：[5, 3, 8, 4, 2]

1. 第一轮遍历：
   1. 比较 5 和 3 → 交换 → [3, 5, 8, 4, 2]
   2. 比较 5 和 8 → 不交换
   3. 比较 8 和 4 → 交换 → [3, 5, 4, 8, 2]
   4. 比较 8 和 2 → 交换 → [3, 5, 4, 2, 8]（最大值已到位）
2. 第二轮遍历（忽略最后一位8）：
   1. 比较 3 和 5 → 不交换
   2. 比较 5 和 4 → 交换 → [3, 4, 5, 2, 8]
   3. 比较 5 和 2 → 交换 → [3, 4, 2, 5, 8]（次大值到位）
   4. 继续进行下去，直到全部有序。

代码示例

冒泡排序 升序

import java.util.Scanner;

public class BubbleSortDemo {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数组长度：");
        int arrLength = scanner.nextInt();

        int[] arr = new int[arrLength];

        for(int i = 0; i < arrLength; i++) {
            int temp = i + 1;
            System.out.println("请输入第" + temp + "个元素值：");
            arr[i] = scanner.nextInt();
        }

        bubbleSort(arr);

        System.out.println("排序后的数组为：");
        for (int i = 0; i < arrLength; i++) {
            System.out.print(arr[i] + " ");
        }

    }

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

            if(!swap) {
                break;
            }

        }
    }
}

选择排序

插入排序

快速排序

归并排序