排序算法

一、稳定性

何为稳定：假设A==B 排序前A再B前面，排序后A依然在B前面，这就是稳定的排序算法

如冒泡排序插入排序归并排序可以是稳定的。快速排序选择排序是不稳定的。

稳定性跟具体算法实现有关：我们说冒泡排序是稳定的如果我们的冒泡算法判断A>=B 则交换A和B，这种写法那就不稳定了

因为A==B的情况下最终排序后A在B之后了。

稳定性好处：多重排序某些场景可以避免不必要的二次排序，我们就拿经常举的例子来看

加入全年级学生已经按学号进行了排序，再按班级排序后，需要满足同一班级的学生学号也是排序的

这样稳定的排序算法按班级排序后，就已经满足要求了；非稳定的排序那必须再进行学号的排序。

二、10大基本排序算法

1、冒泡排序

相连元素两两比较，每轮把最大的往后移，

一轮之后最大的数在最后位置

二轮之后第二大的数在倒数第2的位置

...

2、选择排序

每次选择1个位置存在最大的数

一轮从第2个数开始每个跟第1个数比较，比其大就替换，第一个位置的数最大

二轮从第3个数开始每个跟第2个数比较，比其大就替换，第二个位置的数次大

...

3、快速排序

每次拿出一个数作为基数，一帮是开头的数，后面的数比其小就放入其左边，比其大就放入其右边，左右两个部分再这样处理

二分的思想。

代码如下：

public class QuickSort {
    public static void quickSort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        quickSort(array,0,array.length - 1);
    }
    /**
     * 快排
     * @param array 数组
     * @param start 起点
     * @param end 终点
     * @return 排序后的array
     */
    public static void quickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) {
            return;
        }

        if (array.length == 1) {
            return;
        }

        // 以start为基准(pivot) 把小于start放入左边 大于start的放在右边
        int pivotIndex = sortPivot(array, start, end);
        quickSort(array, start, pivotIndex - 1);
        quickSort(array, pivotIndex + 1, end);
    }

    /**
     *  一轮快排
     *  以start为基准(pivot) 把小于start放入左边 大于start的放在右边
     * @param array
     * @param start
     * @param end
     * @return 基准数最终放入的位置
     */
    public static int sortPivot(int[] array, int start, int end) {
        // 一般以start为基准（任意都可以）
        int pivot = start;
        int indexI = start;
        int indexJ = end;
        /*
         从两端不断的向前走 先处理从后往前，直到遇到某个indexJ小于array[pivot]
         再从start往后 直到遇到一个indexI array[indexI] >= array[pivot]
         交换indexI indexJ ,不断循环直到indexI==indexJ ,交换pivot与indexI
          */
        for (; indexJ > indexI; --indexJ)
            if (array[indexJ] < array[pivot]) {
                for (; indexI<=end;++indexI) {
                    if (array[indexI] >= array[pivot]) {
                        swap(array, indexI,indexJ);
                        break;
                    }
                }
                continue;
            }
        swap(array, pivot,indexI);
            return indexI;
    }

    /**
     * 交换数组内两个元素     * @param array     * @param i     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        if (i == j) {
            return;
        }
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        int[] array = {1,2,6,8,3,9,4};
        quickSort(array);
        System.out.println("sorted array = " + Arrays.toString(array));
    }

}