排序算法对比-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_20198405/article/details/53534852

main方法：

public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i =0;i<10000;i++){
            int x=(int)(Math.random()*100);
            list.add(x);
        }
        // 用list保证每个方法使用的数组一致
        bubbleSort(list);
        selectionSort(list);
        insertionSort(list);
        countingSort1(list);
        countingSort2(list);
}

冒泡排序

通过不停的换位置，确定最大的一个数，然后再来一遍，确定倒数第二个数

    public static void bubbleSort(ArrayList<Integer> list) {
        int size=list.size();  
        Integer[] arr = (Integer[])list.toArray(new Integer[size]);;
        int exchangeCount = 0;
        long compareCount = 0;
        long start = System.currentTimeMillis();
        for (int i = 0; i < arr.length - 1; i++) {
            compareCount++;
            for (int j = 0; j < arr.length - 1 -i; j++) {
                compareCount++;
                compareCount++;
                if (arr[j] > arr[j + 1]) {
                    exchangeCount++;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            compareCount++;
        }
        compareCount++;
        long end = System.currentTimeMillis();
        System.out.println("冒泡排序---end:"+end);
        System.out.println("冒泡排序");
        System.out.println("冒泡排序---用时：end - start =" + (end - start));
        System.out.println("冒泡排序---换位次数：" + exchangeCount);
        System.out.println("冒泡排序---比较次数：" + compareCount);
//      System.out.println("冒泡排序---" + Arrays.toString(arr));
    }

选择排序

不停的比较，确定最小的数，然后从下一个开始，再找到最小的，作为第二个数

    public static void selectionSort(ArrayList<Integer> list) {
        int size=list.size();  
        Integer[] arr = (Integer[])list.toArray(new Integer[size]);;
        int exchangeCount = 0;
        int compareCount = 0;
        long start = System.currentTimeMillis();
        for (int i = 0; i < arr.length - 1; i++) {
            compareCount++;
            for (int j = i + 1; j < arr.length; j++) {
                compareCount++;
                compareCount++;
                if (arr[i] > arr[j]) {
                    exchangeCount++;
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
            compareCount++;
        }
        compareCount++;
        long end = System.currentTimeMillis();
        System.out.println("选择排序");
        System.out.println("选择排序---用时：end - start =" + (end - start));
        System.out.println("选择排序---换位次数：" + exchangeCount);
        System.out.println("选择排序---比较次数：" + compareCount);
//      System.out.println("选择排序---" + Arrays.toString(arr));
    }

复杂度：
其实比较次数也是和冒泡一样——N*(N-1)/2。（N个元素）
但是交换的次数是少于N的，想想冒泡是每次比较完，是需要交换的，而选择只是最后一次。而所以选择排序比冒泡快，当然元素达到一定数量级的时候，速度就体现出来了。

插入排序

每次比较之后，都能保证前面的数据是有序的

    public static void insertionSort(ArrayList<Integer> list) {
        int size=list.size();  
        Integer[] arr = (Integer[])list.toArray(new Integer[size]);;
        int exchangeCount = 0;
        int compareCount = 0;
        int temp;
        int mark;
        long start = System.currentTimeMillis();
        for (int i = 1; i < arr.length; i++) {
            compareCount++;
            temp = arr[i];
            mark = i;
            while (mark > 0 && arr[mark - 1] > temp) {
                compareCount++;
                compareCount++;
                exchangeCount++;
                arr[mark] = arr[mark - 1];
                mark--;
            }
            compareCount++;
            arr[mark] = temp;
        }
        compareCount++;
        long end = System.currentTimeMillis();
        System.out.println("插入排序");
        System.out.println("插入排序---用时：end - start =" + (end - start));
        System.out.println("插入排序---换位次数：" + exchangeCount);
        System.out.println("插入排序---比较次数：" + compareCount);
//      System.out.println("插入排序---" + Arrays.toString(arr));
    }

计数排序

    public static void countingSort(ArrayList<Integer> list) {
        int size=list.size();  
        Integer[] arr = (Integer[])list.toArray(new Integer[size]);;
        int exchangeCount = 0;
        int compareCount = 0;
        long start = System.currentTimeMillis();
        int max =100;
        int[] arrays = new int[max];
        for (int i = 0; i < arr.length; i++) {
            compareCount++;
            arrays[arr[i]]++;
        }
        compareCount++;
        int index = 0;
        for (int i = 0; i < arrays.length; i++) {
            compareCount++;
            // compareCount++;
            // if (array[i] > 0) {
            for (int j = index; j < index + arrays[i]; j++) {
                compareCount++;
                arr[j] = i;
                exchangeCount++;
            }
            index += arrays[i];
            compareCount++;
            // }
        }
        compareCount++;
        long end = System.currentTimeMillis();
        System.out.println("计数排序");
        System.out.println("计数排序---用时：end - start =" + (end - start));
        System.out.println("计数排序---换位次数：" + exchangeCount);
        System.out.println("计数排序---比较次数：" + compareCount);
//      System.out.println("计数排序---" + Arrays.toString(arr));
    }

结果对比：

冒泡排序
冒泡排序---用时：end - start =185
冒泡排序---换位次数：24564659
冒泡排序---比较次数：100009999
选择排序
选择排序---用时：end - start =71
选择排序---换位次数：9999
选择排序---比较次数：100009999
插入排序
插入排序---用时：end - start =52
插入排序---换位次数：24564659
插入排序---比较次数：49149317
计数排序
计数排序---用时：end - start =1
计数排序---换位次数：10000
计数排序---比较次数：20202