排序算法汇总

 1.冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{5, 4, 3, 2, 1};
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }

    public static int[] sort(int[] arr) {
       

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

推导过程

i=1
[5, 4, 3, 2, 1]
j=0      [4, 5, 3, 2, 1]
j=1      [4, 3, 5, 2, 1]
j=2      [4, 3, 2, 5, 1]
j=3      [4, 3, 2, 1, 5]

i=2
j=0  [3, 4, 2, 1, 5]
j=1  [3, 2, 4, 1, 5]
j=2  [3, 2, 1, 4, 5]

i=3 j=0 [2, 3, 1, 4, 5]
j=1 [2, 1, 3, 4, 5]

i=4 j=0 [1, 2, 3, 4, 5]

每一轮循环把最大的元素放到后面,每循环一轮，数组减小一个长度，在减小的长度里面循环比较，直到从小到大排列好

 2. 选择排序

   public static int[] sort(int[] arr) {
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }

推导过程

原始数组 8, 9, 6, 3, 1, 2, 4, 5
i=0,  [1, 9, 6, 3, 8, 2, 4, 5]
i=1   [1, 2, 6, 3, 8, 9, 4, 5]
i=2   [1, 2, 3, 6, 8, 9, 4, 5]
i=3   [1, 2, 3, 4, 8, 9, 6, 5]
i=4   [1, 2, 3, 4, 5, 9, 6, 8]
i=5   [1, 2, 3, 4, 5, 6, 9, 8]
i=6   [1, 2, 3, 4, 5, 6, 8, 9]

总共要经过 N-1 （也就是数组的长度-1） 轮比较 然后每轮在需要比较 N-i 也就是i每次会累加，每轮比较的次数会随着i增加 比较的次数减小

3.插入排序

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 1, 4, 3};
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }

    }

    public static int[] sort(int[] arr) {
        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i++) {
            // 记录要插入的数据
            int tmp = arr[i];
            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }
            // 存在比其小的数，插入
            if (j != i) {
                arr[j] = tmp;
            }
        }
        return arr;
    }
}

推到过程

从下标为1的元素开始循环 用tmp记录下当前下标的数据 把当前下标赋给j 在循环 
如果j>0 并且当前下标数据小于j-1下标的数据进入循环中 循环中内容是把当前j-1的数据赋给j位置的数据
然后j-- 在循环 直到不符合条件 退出循环 然后在判断如果j和i不相等 把tmp的数据赋给当前j位置的数据 然后 继续最外层循环

原始数组 {2, 1, 4, 3}
i=1 [1, 2, 4, 3]
i=2 [1, 2, 4, 3]
i=3  [1, 2, 3, 4]

原始数组 {5,4,3,2,1}

i=1
[5, 4, 3, 2, 1]
[5, 5, 3, 2, 1]
[4, 5, 3, 2, 1]

i=2
[4, 5, 5, 2, 1]
[4, 4, 5, 2, 1]
[3, 4, 5, 2, 1]


i=3
[3, 4, 5, 5, 1]
[3, 4, 4, 5, 1]
[3, 3, 4, 5, 1]
[2, 3, 4, 5, 1]


i=4
[2, 3, 4, 5, 5]
[2, 3, 4, 4, 5]
[2, 3, 3, 4, 5]
[2, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

4.希尔排序