几种简单排序算法_选择排序_冒泡排序_插入排序

一、介绍

1.1 选择排序分析

选择排序：每次循环找出最小值的索引，直接进行交换。

n表示数组长度 ， end 表示最后一次循环。
第1次循环： 在 0 ~ n-1 中找出最小值 ，放在索引为0的位置。
第2次循环： 在 1 ~ n-1 中找出最小值 ，放在索引为1的位置。
第3次循环： 在 2 ~ n-1 中找出最小值 ，放在索引为2的位置。
第4次循环： 在 3 ~ n-1 中找出最小值 ，放在索引为3的位置。
 ....
第n-1次循环： 在 n-2 ~ n-1 中找出最小值 ，放在索引为n-1的位置。

即 每次循环找出最小值直接交换两个元素的位置。

1.2 冒泡排序分析

冒泡排序：每次循环，两两比较，找出最大值，放在最后。

第1次循环：从 0 ~ n-1 范围中 找到最大值，放在n-1位置。
第2次循环：从 0 ~ n-2 范围中 找到最大值，放在n-2位置。
第3次循环：从 0 ~ n-3 范围中 找到最大值，放在n-3位置。
......
第n-1次循环：从 0 ~ 1 范围中 找到最大值，放在1位置。

即：两两比较，每次循环找出最大值，放在最后。

1.3 插入排序分析

第1次循环：从 0 ~ 1 范围中排序
第2次循环：从 0 ~ 2 范围中排序
第3次循环：从 0 ~ 3 范围中排序
......
第n-1次循环：从 0 ~ n-1 范围中排序

即：每次循环，将待排序的值和之前有序的元素进行比较，放在合适的位置。

二、代码实现

/**
 * @author ：LiuShihao
 * @date ：Created in 2022/1/28 5:15 下午
 * @desc ： 选择排序、冒泡排序、插入排序
 */
public class SortCode {

    public static void main(String[] args) {
        int[] arr = {9, 4, 1, 6, 2, 5, 4,1};
        pringArray(arr);
//        selectSort(arr);
//        bubbleSort1(arr);
//        bubbleSort2(arr);
//        insertionSort1(arr);
        insertionSort2(arr);
        pringArray(arr);

    }

    /**
     * 打印数组
     * @param arr
     */
    public static void pringArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();

    }

    /**
     * 交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 选择排序：每次找出最小值
     * 0~n-1 中找出最小的  0-1  1-2  2-3
     * 1~n-1 中找出最小的
     * 2~n-1 中找出最小的
     * 3~n-1 中找出最小的
     * @param arr
     */
    public static void selectSort(int[] arr){
        if (arr == null || arr.length < 2  ){
            return;
        }
        int N = arr.length;
        //i可以从1开始，也可以从0开始（第一位不需要比较）
        for (int i = 1; i < N; i++) {
            int minValueIndex = i;
            //注意：内层循环的初始值是当前值的下一位，即i+1，因为内层循环为当前值和后面的值比较，并记录最小值的位置
            for (int j = i+1; j < N; j++) {
                // 2,1,6,8,1,5
                // 0 1 2 3 4 5
                minValueIndex = arr[minValueIndex] > arr[j] ? j:minValueIndex;
              
            }
            swap(arr,minValueIndex,i);
        }
    }

    /**
     * 冒泡排序：两两相比  交换位置 每次找出最大值。
     * @param arr
     */
    public static void  bubbleSort1(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
      
        int N = arr.length;
        // 0 ~ n-1
        // 0 ~ n-2
        // 0 ~ n-3
        //外层循环控制次数
        for (int i = 1; i < N; i++) {
            //内层循环进行两两比较，从索引0位置开始两两比较  即：j和j+1进行比较，j++，此处 限制条件：j < N-1 和j < N-1-i 效果是一样的。
            for (int j = i; j < N-1; j++) {
                if (arr[j] > arr[j+1]){
                    swap(arr,j+1,j);
                }
            }
        }

    }

    /**
     * 冒泡排序第二种写法：
     * @param arr
     */
    public static void bubbleSort2(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
       
        int N = arr.length;
        // 0 ~ n-1
        // 0 ~ n-2
        // 0 ~ n-3
        // 0 ~ n-4
        // end 为最后位置
        for (int end = N-1; end > 0; end--) {
        	//second 为比较的第二位元素，second-1为比较的第一位值，所以second 从1 开始比较，选出最大的值放在end的位置。
            for (int second = 1; second <= end ; second++) {
                if (arr[second-1] > arr[second]){
                    swap(arr,second-1,second);
                   
                }
            }
        }
    }

    /**
     * 插入排序第一种写法：
     * 0 ~ n-1
     * 1 ~ n-1
     * 2 ~ n-1
     * 3 ~ n-1
     * @param arr
     */
    public static void insertionSort1(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        int N = arr.length;
        for (int i = 1; i < N; i++) {
        	// nextValueIndex为待排序新值的位置。如果符合条件的话则交换位置，并--，再与前面的元素比较，直到找到合适的位置停止，之前已经是有序的了。
            int nextValueIndex = i ;
            while ((nextValueIndex -1)>=0 && (arr[nextValueIndex] < arr[nextValueIndex-1])){
                swap(arr,nextValueIndex,nextValueIndex-1);
                nextValueIndex--;
            }
        }
       
    }

    /**
     * 插入排序第二种写法：
     * @param arr
     */
    public static void insertionSort2(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        int N = arr.length;
        // end 为待排序的新值的位置
        for (int end = 1; end < N; end++) {
        	// pre 为前一位元素的位置
            for (int pre = end -1 ; pre >= 0 &&(arr[pre] > arr[pre+1]); pre--) {
                swap(arr,pre,pre+1);
          
            }
        }
    }
}