常用排序算法整理

最近整理了一些常用的排序算法，主要是下面几个排序算法：

- 冒泡排序
- 快速排序
- 选择排序
- 插入排序
- 希尔排序
- 归并排序
- 堆排序
- 基数排序
- 桶排序

1.冒泡排序

每次确定一个元素放在最后，然后从头开始下一轮

 /**
     * 稳定排序
     * 冒泡排序
     * @param a
     */
    public static void buddleSort(int[] a) {
        System.out.print("排序前数组：");
        System.out.println(Arrays.toString(a));
        if (a == null) {
            return;
        }

        int len = a.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - i -1; j++) {
                if (a[j] < a[j+1]) {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.print("排序后数组：");
        System.out.println(Arrays.toString(a));
    }

2.快速排序

同样每次确定一个元素，但是确定的是第一个元素所在的位置，然后递归对该位置左右两部分排序

/**
     * 不稳定排序
     * 快速排序
     * @param a
     * @param left
     * @param right
     */
    public static void quickSort(int[] a, int left, int right) {
        if (a == null || left > right) {
            return;
        }
        if (right - left <= 1) {
            return;
        }
        int temp = a[left];
        int start = left;
        int end = right;
        while (left != right) {
            while (a[right] > temp && right > left) {
                right--;
            }

            if (left < right) {
                a[left] = a[right];
                left++;
            }

            while (a[left] < temp && left < right) {
                left++;
            }

            if (left < right) {
                a[right] = a[left];
                right--;
            }

        }
        a[left] = temp;
        quickSort(a, start, left-1);
        quickSort(a, left+1, end);
    }

3.选择排序

每次遍历选择最小的元素放在第一个位置

/**
     * 不稳定排序
     * 选择排序
     * @param a
     */
    public static void selectSort(int[] a) {
        if (a == null || a.length == 0) {
            return;
        }
        System.out.print("排序前数组：");
        System.out.println(Arrays.toString(a));
        int len = a.length;
        for (int i = 0; i < len -1; i++) {
            for (int j = i + 1; j < len; j++) {
                if (a[i] > a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }

        System.out.print("排序后数组：");
        System.out.println(Arrays.toString(a));
    }

4.插入排序

第一个是每次往前插入都交换位置，第二个是先保存，然后后移元素，最后放入到合适位置。后面的希尔插入就是用的第二种

 /**
     * 稳定排序
     * @param a
     */
    public static void insertSort(int[] a) {
        if (a == null || a.length