Java - 算法

冒泡算法

比较两个相邻的元素,如果它们的顺序不符合要求,就交换它们的位置。 经过多轮比较和交换,数组最终变为有序状态。

每一轮结束时,当前未排序部分的最大值都会移动到最右边。因此,下一轮不必再比较已经排好序的末尾元素。

        int[] arr = {5, 3, 8, 2, 4};
        for (int i=0;i<arr.length-1;i++){
            //第一轮过后,最后一个元素不用比较
            //第二轮过后,最后一个元素和倒数第二个元素不用比较,以此类推
            for (int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
轮次 本轮结束后的数组 本轮确定的元素
初始 5, 3, 8, 2, 4 —
第 1 轮 3, 5, 2, 4, 8 8
第 2 轮 3, 2, 4, 5, 8 5
第 3 轮 2, 3, 4, 5, 8 4
第 4 轮 2, 3, 4, 5, 8 3

选择排序

每一轮从尚未排序的元素中,找出最小值,再将它与未排序部分的第一个元素交换位置。

选择排序是先找到最小值,再进行交换。

一、选择排序的执行过程

假设有一个数组,需要按照从小到大的顺序排列:

int[] arr = {5, 3, 8, 2, 4};

第一轮:在整个数组中寻找最小值 2,将它与第一个元素 5 交换。

最小值是 2,与第一个元素 5 交换

第一轮结束:第一个元素 2 已经确定位置。

后续各轮:

轮次 待排序部分 找到的最小值 交换后数组
初始 5, 3, 8, 2, 4 — 5, 3, 8, 2, 4
第 1 轮 5, 3, 8, 2, 4 2 2, 3, 8, 5, 4
第 2 轮 3, 8, 5, 4 3 2, 3, 8, 5, 4
第 3 轮 8, 5, 4 4 2, 3, 4, 5, 8
第 4 轮 5, 8 5 2, 3, 4, 5, 8

注意:第二轮中,最小值 3 已经位于待排序部分的第一个位置,因此不需要交换。

二、Java 代码实现

public class SelectionSort {

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 2, 4};

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;

            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }

            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }

        for (int n : arr) {
            System.out.print(n + " ");
        }
    }
}

输出:

2 3 4 5 8

三、逐行理解代码

1. 外层循环:控制排序轮数

for (int i = 0; i < arr.length - 1; i++)

i 表示当前需要放置最小值的位置。

例如:

  • i = 0:确定整个数组中的最小值。
  • i = 1:确定剩余元素中的最小值。
  • i = 2:确定再往后部分的最小值。

数组长度为 \(n\) 时,最多需要 \(n-1\) 轮。

2. 假设当前元素就是最小值

int minIndex = i;

minIndex 用来保存当前最小元素的索引,而不是元素本身。

例如,数组是:

{5, 3, 8, 2, 4}

当 i = 0 时,先假设:

minIndex = 0;

也就是暂时认为 arr[0],即 5,是最小值。

3. 内层循环:寻找真正的最小值

for (int j = i + 1; j < arr.length; j++) {
    if (arr[j] < arr[minIndex]) {
        minIndex = j;
    }
}

从当前元素的下一个位置开始,依次比较。

以第一轮为例:

j 当前元素 当前最小值 minIndex
初始 5 5 0
1 3 3 1
2 8 3 1
3 2 2 3
4 4 2 3

循环结束后,minIndex = 3,说明最小值 2 位于索引 3。

这里要特别注意:内层循环只寻找最小值的索引,不交换数组元素。

4. 交换最小值与当前位置的元素

int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;

第一轮结束时:

  • arr[i] 是 5。
  • arr[minIndex] 是 2。

交换之后,数组变成:

{2, 3, 8, 5, 4}

至此,第一轮选择排序结束。

选择排序的一个特点是:即使数组已经有序,它仍然需要扫描未排序部分寻找最小值,因此比较次数不会减少。

posted @ 2026-10-28 20:08  dvdhellohaha  阅读(5)  评论(0)    收藏  举报