算法学习（二）选择排序，冒泡排序，插入排序

原创

mb663999a7e9fc1 2024-05-07 11:06:09 ©著作权

©著作权归作者所有：来自51CTO博客作者mb663999a7e9fc1的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.选择排序

选择排序是一种简单的排序算法，其基本思想是每次从待排序的数据中选择最小（或最大）的元素，将其放到已排序序列的末尾。

以下是选择排序的Java实现：

java复制代码运行
public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换最小值和当前位置的值
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        selectionSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了选择排序算法，通过不断选择最小元素并将其放到已排序序列的末尾，最终得到一个有序的数组。在示例中，输入数组为{64, 34, 25, 12, 22, 11, 90}，经过选择排序后，输出结果为{11, 12, 22, 25, 34, 64, 90}。

总结

选择排序的流程可以概括为以下几个步骤：

找到最小值：从待排序的数组中找到最小的元素。
交换位置：将这个最小元素与数组中的第一个元素交换位置。
缩小范围：将待排序的范围缩小，即忽略已经排在第一位的最小元素。
重复过程：重复以上步骤，每次都在剩余的未排序的元素中找到最小的元素，然后将其放到已排序序列的末尾。
循环结束：当所有元素都被遍历过一次，且都放在了正确的位置上时，排序完成。

通过这个过程，数组中的元素将逐渐从无序状态变为有序状态。这种排序方法简单易懂，但并不是最高效的排序算法，特别是在处理大量数据时。

2.冒泡排序

冒泡排序是一种简单的排序算法，它通过重复地比较相邻元素并交换它们的位置来将较大的元素逐渐"浮"到数组的末尾。

以下是冒泡排序的Java实现：

java复制代码运行
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻位置的元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了冒泡排序算法，通过不断比较相邻元素的大小并进行交换，将较大的元素逐渐"浮"到数组的末尾。在示例中，输入数组为{64, 34, 25, 12, 22, 11, 90}，经过冒泡排序后，输出结果为{11, 12, 22, 25, 34, 64, 90}。

总结

冒泡排序的流程可以概括为以下几个步骤：

比较相邻元素：从数组的第一个元素开始，依次比较相邻的两个元素。
交换位置：如果前一个元素大于后一个元素，则交换它们的位置。
缩小范围：每进行一轮比较和交换后，将待排序的范围缩小，即忽略已经排好序的元素。
重复过程：重复以上步骤，直到整个数组都排好序为止。
循环结束：当所有元素都被遍历过一次，且都放在了正确的位置上时，排序完成。

通过这个过程，数组中的元素将逐渐从无序状态变为有序状态。冒泡排序的时间复杂度为O(n^2)，在处理大量数据时效率较低，但它的实现简单易懂，适用于小规模数据的排序。

3.插入排序

插入排序是一种简单的排序算法，它通过构建有序序列，将未排序的元素逐个插入到已排序序列中的正确位置。

以下是插入排序的Java实现：

java复制代码运行
public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        insertionSort(arr);
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了插入排序算法，通过构建有序序列，将未排序的元素逐个插入到已排序序列中的正确位置。在示例中，输入数组为{64, 34, 25, 12, 22, 11, 90}，经过插入排序后，输出结果为{11, 12, 22, 25, 34, 64, 90}。