java十大排序

1.冒泡排序

• 基本思想：持续比较相邻的元素。如果第一个比第二个大，就交换他们两个。直到没有任何一对数字需要比较。
• 冒泡排序最好的时间复杂度为O(n)。冒泡排序的最坏时间复杂度为O(n^2)。因此冒泡排序总的平均时间复杂度为O(n^2)。
• 算法适用于少量数据的排序，是稳定的排序方法。
• 最佳情况：T(n) = O(n)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(n2)

public class BubbleSort {

    public static int[] sort(int[] array) {
        //排除数组为0的情况
        if (array.length == 0) {
            return array;
        }

        //定义一共比较多少轮，一般为array.length-1
        for (int i = 0; i < array.length; i++) {
            //定义一个标志位，用来判断数组是否提前排好了顺序
            boolean flag=true;
            //定义一共比较多少轮，一般是array.length-1-i,通过1轮比较后，
            // 总能把最大的数排到最后
            for (int j = 0; j < array.length - 1 - i; j++) {
                //如果左边比右边大，就交换位置，这样
                // 总能把最大的数排到最后
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    //只要交换了一次位置，那么数组肯定没有提前排好序
                    flag=false;
                }
            }
            System.out.println("第"+i+"轮排序结果");
            display(array);
            //如果如果提前拍好了序，那么肯定不会交换
            // 操作，这样flag为true,提前结束循环
            //冒泡排序能保证每次排序后，最后的值都是有序最大的，
            //所以如果没有执行交换操作，那么说明前面的值也是有序的
            //这样整体的代码都是有序的，提前结束循环即可
            if(flag){
                break;
            }
        }
        return array;
    }

    public static void display(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 2, 4, 6, 1};
        sort(arr);
        display(arr);
    }
}

2.选择排序

• 基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
• 选择排序是不稳定的排序方法。
• 最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

public class SelectSort {
    public static int[] sort(int[] array) {
        //排序数组为空的情况
        if (array.length == 0) {
            return array;
        }

        //定义排序的轮次，一般为array.length-1
        for (int i = 0; i < array.length; i++) {
            //定义最小的index，默认为i,因为每排序一次，最小的值总会在最左边
            int min = i;
            //定义比较的次数，一般是array.length-1
            for (int j = i; j < array.length; j++) {
                //如果最小下标的数组值大于数组中的值
                if (array[j] <array[min]) {
                    //记录下标
                   min=j;
                }
            }
            //交换数组值
            int temp=array[i];
            array[i]=array[min];
            array[min]=temp;
            display(array);
        }
        return array;
    }

    public static void display(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 2, 4, 6, 7};
        sort(arr);
        display(arr);
    }
}

3.插入排序

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。
• 最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

public class InsertionSort {
    public static int[] insertionSort(int[] array) {
        if (array.length == 0)
            return array;
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
            display(array);
        }
        return array;
    }


    public static void display(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 2, 4, 6, 7};
        insertionSort(arr);
        display(arr);
    }
}

4.希尔排序

 

参考https://www.cnblogs.com/guoyaohua/p/8600214.html