排序算法（中）-优快云博客

本文链接：https://blog.youkuaiyun.com/u010449115/article/details/57415158

本文接着排序算法（上）的内容继续介绍交换排序（冒泡排序和快速排序）和插入排序（插入排序、Shell排序）。

冒泡排序

冒泡排序是最广为人知的、最简单的排序算法，其实现步骤如下：

从第一个元素开始，一次将其与后边的元素比较，如果前边的元素大于后边的，就将前边的元素向后移，如此最后一个元素就为最大值；
重复以上操作，将第二大元素移动到倒数第二位；
重复，直到所有元素军变为有序的。

public class BubbleSort {

    public static void bubbleSort(DataWrap[] data) {
        for (int i = 0; i < data.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0) {
                    swap(data, j, j + 1);
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }
    }

    // 交换两个元素
    private static void swap(DataWrap[] data, int i, int j) {

        DataWrap temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    public static void main(String[] args) {
        DataWrap[] data = { new DataWrap(21, " "), new DataWrap(49, " "),
                new DataWrap(30, " "), new DataWrap(16, " "),
                new DataWrap(30, "*"), new DataWrap(9, " ") };

        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }
}

冒泡排序有以下三个特点：

冒泡排序最好的情况（及数组本身有序）只需要进行n-1比较即可，无需进行交换，最差的情况即逆序，需要进行n(n-1)/2次比较，需要3n(n-1)/2次移动；
空间复杂度O（1）；
冒泡排序是稳定的；
冒泡排序可以用一个变量来检查数组是否有序。

插入排序

插入排序重复如下过程：每次从输入数据中移除一个元素，并将该元素插入到已经排好序的序列的适当位置。

public static void insertSort(int[] A){
        int i,j;
        for (i = 0; i < A.length; i++) {
            for (j = i;j > 0;j--) {
                if(A[j] < A[j - 1]){
                    swap(A,j,j - 1);
                }
            }
        }
    }

插入排序的特点：
1、平均情况下插入排序需要进行n*n/4次比较和n*n/4次的交换，最好情况下需要进行n-1次比较和0次交换；
2、插入排序需要的交换次数和数组中的倒置数量相同，需要的比较次数大于等于倒置的数量，小于等于倒置的数量加上数组的大小减1；
3、插入排序对于部分有序的数组排序十分高效，也适合数组规模较小时的排序；
4、插入排序常常是高级排序算法的中间过程。

希尔排序

希尔排序的思想是使数组中任意间隔为h的元素都是有序的，是对插入排序的一种扩展。由于可以交换数组中距离为h的两个元素，因此在某些场合可以有效减少交换的次数。

这里写图片描述

public static void shellSort(int[] A){
        int n = A.length;
        int i,j,h;
        for(h = 1;h < n / 3;){//构造递增序列
            h = 3 * h + 1;
        }
        for(;h >= 1;h = h / 3){
            for(i = h;i < n;i++){
                for(j = i;j >= h;j -= h){
                    if(A[j] < A[j - h]){
                        swap(A,j,j-h);
                    }
                }
            }
        }
    }