【算法】简单排序（选择，冒泡，插入）

1、 什么是简单排序

简单排序是指基于比较的排序算法，包括冒泡排序、选择排序和插入排序。这些算法通常容易理解和实现，但在实际应用中，它们的效率通常比高级排序算法慢。

2、 复杂度分析

1. 选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。不稳定的排序

2. 冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。稳定的排序

3. 插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。稳定的排序

2.1 【选择排序】代码

	/**
	 * 选择排序
	 * 时间复杂度：O(n^2)
	 * 空间复杂度：O(1)
	 */
    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[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

2.2 【冒泡排序】代码

	/**
	 * 冒泡排序
	 * 时间复杂度：O(n^2)
	 * 空间复杂度：O(1)
	 */
    public static void bubbleSort(int[] arr) {
        int n = arr.length;

        // 进行n-1轮冒泡
        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;
                }
            }
        }
    }

2.3 【插入排序】代码

	/**
	 * 插入排序
	 * 时间复杂度：O(n^2)
	 * 空间复杂度：O(1)
	 */
    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;
            
            // 将比key大的元素向后移动，为key找到合适的位置
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            
            // 将key插入到合适的位置
            arr[j + 1] = key;
        }
    }

时间复杂度分析：

• 由于嵌套了两个for循环，所以总的时间复杂度为O(n^2)
• 对于每个元素进行比较和交换操作都是常数时间O(1)

空间复杂度分析：

• 只需使用常数个额外空间来存储变量，所以空间复杂度为O(1)