七种排序算法的总结（java版）

最近，在准备校招的基础学习，复习了一下排序算法，自己又重新温故了一边，并把这几种排序算法的原理重点复习，研究并总结了一下，用代码实现了一遍。

**排序工具类如下**

package al;

/**
 * 七大排序算法
 * 快速排序、希尔排序、堆排序、直接选择排序不是稳定的搜索排序算法  快选希堆不稳定
  *冒泡排序、直接插入排序、归并排序是稳定的排序算法
 * @author MSI
 */
public class SortUtil {

    /**
     * 交换函数
     */
    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }

     /**
     * 一、冒泡排序： 每一次排序过程是一次冒泡过程，将大的值往后移动，一次过程确定一个最大值； 平均时间
     *    复杂度O(n^2) 
     *    稳定排序
     */
    public static void bubbleSort(int[] array, int length) {
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
    }

    /**
     * 二，插入排序：每一次排序挑选一个为排序数，插入已经排好序列的数组 平均时间复杂度：O(n^2) 
     *    稳定排序
     */
    public static void insertSort(int[] array, int length) {
        for (int i = 1; i < length; i++) {
            int index = i;
            while (index > 0 && array[index] < array[index - 1]) {
                // 只要大于前面的数就交换，直到条件不满足
                swap(array, index, index - 1);
                // 交换一次后指针往前移动一位，继续比较；
                index--;
            }
        }
    }

    /**
     * 三、选择排序： 每一次排序找到数组中最小元素，放入数组最前端，一次过程确定一个最小值； 平均时间复
     *    杂度O(n^2); 不稳定排序
     */
    public static void selectSort(int[] array, int length) {
        for (int i = 0; i < length - 1; i++) {
            int index = i;
            for (int j = i + 1; j < length; j++) {
                if (array[index] > array[j]) {
                    index = j;
                }
            }
            swap(array, i, index);
        }
    }


     /**
     * 四、快速排序 选择一个基数，前后两个指针，从后往前遍历，遇见小于自己的数，交换位置，再从前往后遍
     *    历，大于自己的交换 直到前后两个指针重合，一次快排结束； 
     *    平均时间复杂度：O(nlogn) 不稳定排序
     */
    public static void quickSort(int[] array, int low, int high) {
        if (low > high) {
            return;
        }
        int l = low;
        int r = high;
        int index = array[l];
        while (l < r) {
            // 如果右边的数大于指数，则右指针左移；
            while (l < r && array[r] > index) {
                r--;
            }
            // 右边数小于指针，则赋值；
            if (l < r) {
                array[l++] = array[r];
            }
            // 如果左边的数小于指数，则左指针右移；
            while (l < r && index > array[l]) {
                l++;
            }
            // 左边数大于指针，则赋值
            if (l < r) {
                array[r--] = array[l];
            }
        }
        array[l] = index;
        quickSort(array, low, l - 1);
        quickSort(array, l + 1, high);
    }



    /**
     * 五、归并排序： 将大数组分割成若干个小数组，排序后进行递归归并； 平均时间复杂度O(nlogn);
     *    需要辅助空间； 稳定排序
     */
    // 分开过程
    public static void MergeSort(int[] array, int low, int high, int[] temp) {
        if (low >= high) {
            return;
        }
        int mid = (low + high) / 2;
        // 继续分割
        MergeSort(array, low, mid, temp);
        MergeSort(array, mid + 1, high, temp);
        // 不能分割后进行排序
        Merge(array, low, mid, high, temp);
    }

    // 合并过程
    public static void Merge(int[] array, int low, int mid, int high, int[] temp) {
        int i = low;
        int j = mid + 1;
        int size = 0;
        // 归并是进行比较
        while (i <= mid && j <= high) {
            if (array[i] < array[j]) {
                temp[size++] = array[i++];
            } else {
                temp[size++] = array[j++];
            }
        }
        while (i <= mid) {
            temp[size++] = array[i++];
        }
        while (j <= high) {
            temp[size++] = array[j++];
        }
        // 将临时数组中的数，放置到原数组中
        for (i = 0; i < size; i++) {
            array[low + i] = temp[i];
        }
    }


    /**
     * 六、希尔排序 对待排记录序列先作“宏观”调整，再作“微观”调整。所谓“宏观”调整，指的是“跳跃式”的插入
     *    排序。
     *    即：将记录序列分成若干子序列，每个子序列分别进行插入排序。
     */
    public static void shellSort(int[] array, int length) {
        // 定义步长，依次减半；
        for (int step = length / 2; step > 0; step = step / 2) {
            // 从选取步长依次进行比较
            for (int i = step; i < length; i++) {
                for (int j = i - step; j >= 0; j = j - step) {
                    // 如果小于步长前的值，则进行交换
                    if (array[j] > array[j + step]) {
                        swap(array, j, j + step);
                    } else {
                        break;// 如果大于，则不用在进行插入了，因为该步长前的数都已经有序；
                    }
                }
            }
        }
    }


    /**
     * 七、 堆排序: 最大堆排序，每次构建一个最大堆，将最大的数与数组最后一个交换，再递归进行前n-1个数堆
     *     排序；
     */
    public static void heapSort(int[] array, int length) {
        if (length > 0) {
            // 循环到拥有左孩子的最后一个位置
            for (int i = 0; 2 * i + 1 <= length; i++) {
                boolean flag = buildHeap(array, length, i);
                if (flag) {
                    i = -1;// 若堆进行了调整，则需重新开始进行堆排序；
                }
            }
            // 交换最大值到数组最后一个数；
            swap(array, 0, length);
            // 进行递归排序
            heapSort(array, length - 1);
        }
        return;
    }

    // 调整堆方法:返回是否调整了堆结构
    public static boolean buildHeap(int[] array, int length, int i) {
        int l = 2 * i + 1;// 定义左孩子
        int r = l + 1;// 定义右孩子
        // 若不存在右孩子，则直接进行比较交换；
        if (r > length) {
            if (array[l] > array[i]) {
                swap(array, i, l);
                return true;
            } else {
                return false;
            }
        }
        // 若存在，左右孩子，则把最大的数交换个父节点；
        int max = array[l] > array[r] ? l : r;// 定义最大数位置；
        if (array[i] < array[max]) {
            swap(array, i, max);
            return true;
        }
        return false;
    }
    }

测试类如下

package al;

public class Test {
    public static void main(String[] args) {
        int[] array = { 8, 11, 14, 2, 6, 5, 23, 9, 1, 5 };
        int length = array.length;
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println();
        // SortUtil.bubbleSort(array, length);
        // SortUtil.insertSort(array, length);
        // SortUtil.insertSort(array, length);
        // SortUtil.quickSort(array, 0, length-1);
        // int[] temp = new int[length];
        // SortUtil.MergeSort(array, 0, length-1, temp);
        // SortUtil.shellSort(array, length);
        SortUtil.heapSort(array, length - 1);
        for (int i : array) {
            System.out.print(i + " ");
        }
    }

}