常用的排序算法及其Java实现（上）

最近找工作时内问到有关排序算法的相关问题，在这里总结一下常用的排序算法，并且进行了比较

1、插入排序，把当前待排序的元素插入到一个已经排好序的队列中，插入排序的最坏运行时间为O(n^2)，其实插入排序可以比作我们在打牌时，往已经排好的牌中插入一张新牌。插入排序是稳定的排序。插入排序的java实现如下，

public static void insertSort(int[] array) {
   for (int i = 0; i < array.length; i++) {
        int current = array[i];
        int position = i;
        for (int j = i - 1; j >= 0; j--) {
            if (current < array[j]) {
                array[j + 1] = array[j];
                position--;
            } else {
                break;
            }
        }
        array[position] = current;
    }
    System.out.println(Arrays.toString(array));
}

2、选择排序，从待排序数组中选择出最小的元素然后与顶部元素交换，选择排序的运行时间为O(n^2)，选择排序会破坏原有的顺序，所以选择排序不是一个稳定的排序，例如：5-1，8，5-2，2，9，第一趟选择排序后的结果为2,8，5-2,5-1,9，此时2个5之间的原有顺序会被改变，选择排序的java代码如下：

public static void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int temp = i;
        for (int j = i; j < array.length; j++) {
            if (array[temp] > array[j])
                temp = j;
        }
        if (i != temp) {
            int t;
            t = array[temp];
            array[temp] = array[i];
            array[i] = t;
        }
    }
    System.out.println(Arrays.toString(array));
}

3、冒泡排序：最大的元素会移动到最右端，冒泡排序是一种稳定的排序，时间复杂度为：O(n^2)，冒泡排序的java实现为：

public static void bubSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        for (int j = i; j < array.length; j++) {
            if (array[i] > array[j]) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(array));
}

4、希尔排序（缩小增量发），将整个无序序列分割成若干个小的子序列分别进行插入排序希尔排序不是稳定的排序，时间复杂度为O(nlogn)，对于希尔排序来说，这个增量的选择极为重要可以影响到排序的时间复杂度，一般选择使用序列的1/2，往下递归来实现，希尔排序的时序图如下：

希尔排序的java实现如下：

public static void shellSort(int[] array) {
    for (int increament = array.length / 2; increament > 0; increament = increament / 2) {
        for (int i = 0; i < increament; i++) {
            for (int k = i; k < array.length; k = k + increament) {
                int t = k, current = array[k];
                for (int j = k - increament; j >= 0; j = j - increament) {
                    if (current < array[j]) {
                        array[j + increament] = array[j];
                        t = t - increament;
                    } else {
                        break;
                    }
                }
                if (t != k)
                    array[t] = current;
            }
        }
    }

    System.out.println(Arrays.toString(array));
}