Java实现七大算法(插入\希尔\选择\堆排\冒泡\快排\归并)

本文内容：
1、排序算法比较
2、代码实例

1、排序算法比较

排序法        最差时间分析   平均时间复杂度     稳定度      空间复杂度
冒泡排序        O(n2)          O(n2)           稳定         O(1)
快速排序        O(n2)        O(nlog2n)        不稳定     O(log2n)~O(n)
选择排序        O(n2)          O(n2)           稳定         O(1)
堆排序          O(n2)        O(nlog2n)        不稳定        O(1)
插入排序        O(n2)          O(n2)           稳定         O(1)
归并排序        O(nlog2n)     O(nlog2n)        稳定         O(n)
希尔排序        O(n2)         O(nlog2n)        不稳定       O(1)

2、代码实例

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class Solution {
    private static int[] bubbleArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] selectArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] insertArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] shellArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] fastArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] heapArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};
    private static int[] mergeArr = new int[]{23, 35, 2, 7, 3, 14, 14, 9, 9, 8, 2, 18, 520, 1314, 1};


    /**
     * 冒泡排序
     *
     * @param arr
     * @return
     */
    public static int[] bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }


    /**
     * 快速排序
     *
     * @param arr
     * @param head
     * @param tail
     * @return
     */
    public static int[] fastSort(int[] arr, int head, int tail) {
        if (arr.length < 1) return arr;
        int base = arr[head];
        int i = head;
        int j = tail;
        if (i < j) {
            while (i < j && arr[i] < base) {
                i++;
            }
            while (j > i && arr[j] > base) {
                j--;
            }
            if (i <= j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
                j--;
            }
            if (head < j) {
                fastSort(arr, head, j);
            }
            if (i < tail) {
                fastSort(arr, i, tail);
            }
        }
        return arr;
    }


    /**
     * 插入排序
     *
     * @param arr
     * @return
     */
    public static int[] insertSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        return arr;
    }


    /**
     * 希尔排序
     *
     * @param arr
     * @return
     */
    public static int[] shellSort(int[] arr) {
        int group = arr.length / 2;
        while (group > 0) {
            for (int i = 0; i < arr.length; i += group) {
                for (int j = i; j >= group; j -= group) {
                    if (j < group) break;
                    if (arr[j] < arr[j - group]) {
                        int temp = arr[j];
                        arr[j] = arr[j - group];
                        arr[j - group] = temp;
                    }
                }
            }
            group /= 2;
        }
        return arr;
    }

    /**
     * 选择排序
     *
     * @param arr
     * @return
     */
    public static int[] selectSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < arr[i]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 堆排序
     *
     * @param arr
     * @return
     */
    public static int[] heapSort(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            int node = (i - 1) / 2;
            for (int j = node; j >= 0; j--) {
                if (arr[j] < arr[2 * j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[2 * j + 1];
                    arr[2 * j + 1] = temp;
                }
                if ((2 * j + 2) > i) continue;
                if (arr[j] < arr[2 * j + 2]) {
                    int temp = arr[j];
                    arr[j] = arr[2 * j + 2];
                    arr[2 * j + 2] = temp;
                }
            }
            int temp2 = arr[0];
            arr[0] = arr[i];
            arr[i] = temp2;
        }
        return arr;
    }

    /**
     * 归并排序
     *
     * @param arr
     * @param head
     * @param tail
     * @return
     */
    public static int[] mergeSort(int[] arr, int head, int tail) {
        int mid = (head + tail) / 2;
        if (head < tail) {
            mergeSort(arr, head, mid);
            mergeSort(arr, mid + 1, tail);
            merge(arr, head, mid, tail);
        }
        return arr;
    }

    public static void merge(int[] arr, int head, int mid, int tail) {
        int[] temp = new int[tail - head + 1];
        int i = head;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= tail) {
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= tail) {
            temp[k++] = arr[j++];
        }
        for (int x = 0; x < temp.length; x++) {
            arr[x + head] = temp[x];
        }
    }

    public static void main(String[] args) {
        System.out.println("==============冒泡==============");
        for (int a : Solution.bubbleSort(bubbleArr)) {
            System.out.println(a);
        }

        System.out.println("==============快排==============");
        for (int a : Solution.fastSort(fastArr, 0, fastArr.length - 1)) {
            System.out.println(a);
        }

        System.out.println("==============插入==============");
        for (int a : Solution.insertSort(insertArr)) {
            System.out.println(a);
        }

        System.out.println("==============希尔==============");
        for (int a : Solution.shellSort(shellArr)) {
            System.out.println(a);
        }

        System.out.println("==============选择==============");
        for (int a : Solution.selectSort(selectArr)) {
            System.out.println(a);
        }

        System.out.println("==============堆排==============");
        for (int a : Solution.heapSort(heapArr)) {
            System.out.println(a);
        }

        System.out.println("==============归并==============");
        for (int a : Solution.mergeSort(mergeArr, 0, mergeArr.length - 1)) {
            System.out.println(a);
        }
    }
}