java 实现七大基本排序算法

一、 选择排序

    /**
     * 选择排序: int arr[] = { 5, 6, 2, 7, 8, 6, 4 };
     *
     *  第0趟
        5 2 6 7 6 4 8
        第1趟
        2 5 6 6 4 7 8
        第2趟
        2 5 6 4 6 7 8
        第3趟
        2 5 4 6 6 7 8
        第4趟
        2 4 5 6 6 7 8
        第5趟
        2 4 5 6 6 7 8
        第6趟
        2 4 5 6 6 7 8
     */
    public void selectSorted(int arr[]) {

        int n = arr.length;
        for (int i = 0; i < n; i++) {

            for (int j = 0; j < n - 1; j++) {

                if (arr[j + 1] < arr[j])
                    swap(arr, j, j + 1);
            }
            System.out.println("\n" + "第" + i + "趟");
            printArray(arr);
        }
    }

二、插入排序

    /**
     * 插入排序 : int arr[] = { 5, 6, 2, 7, 8, 6, 4 };
     *  第1趟
        5 6 2 7 8 6 4
        第2趟
        2 5 6 7 8 6 4
        第3趟
        2 5 6 7 8 6 4
        第4趟
        2 5 6 7 8 6 4
        第5趟
        2 5 6 6 7 8 4
        第6趟
        2 4 5 6 6 7 8
     */
    public void insertSorted(int arr[]) {

        int n = arr.length;

        for (int i = 1; i < n; i++) {

            for (int j = i; j > 0; j--) {

                if (arr[j] < arr[j - 1])
                    swap (arr,j, j - 1);
            }
            System.out.println("\n" + "第" + i + "趟");
            printArray(arr);
        }

    }

    // 效率更优,减少不必要的交换
    public void insertSorted2(int arr[]) {

        int n = arr.length;

        for (int i = 1; i < n; i++) {

            int ele = arr[i];  // 当前待比较的元素
            int j;               // 当前元素最终的下标位置
            for (j = i; j > 0 && arr[j - 1] > ele; j--)
                arr[j] = arr[j - 1];
            arr[j] = ele;

            System.out.println("\n" + "第" + i + "趟");
            printArray(arr);
        }
    }

三、冒泡排序

    /**
     * 冒泡排序 : int arr[] = { 5, 6, 2, 7, 8, 6, 4 };
     *
     *     第0趟
        5 2 6 7 6 4 8
        第1趟
        2 5 6 6 4 7 8
        第2趟
        2 5 6 4 6 7 8
        第3趟
        2 5 4 6 6 7 8
        第4趟
        2 4 5 6 6 7 8
        第5趟
        2 4 5 6 6 7 8
        第6趟
        2 4 5 6 6 7 8
     */
    public void bubbleSorted(int arr[]) {

        int n = arr.length;

        for (int i = 0; i < n; i++) {

            for (int j = 0; j < n - i - 1; j++)
                if ( arr[j] > arr[j + 1])
                    swap(arr, j, j + 1);

            System.out.println("\n" + "第" + i + "趟");
            printArray(arr);

        }
    }

四、归并排序

    /**
     * 归并排序 :
        4 5 2 7 1 6 3
        4 5 2 7 1 6 3
        2 4 5 7 1 6 3
        2 4 5 7 1 6 3
        2 4 5 7 1 3 6
        1 2 3 4 5 6 7
     */
    public void mergeSorted(int arr[]) {

        int n = arr.length - 1; // 闭区间
        splitArray(arr, 0, n);

    }

    private void splitArray(int[] arr, int L, int R) {

        if (L >= R) {
            return;
        }

        int mid = L + (R - L) / 2;

        splitArray(arr, L, mid);
        splitArray(arr, mid + 1, R);

        // merge(arr, L, mid, R);

        // 优化
        if (arr[mid] > arr[mid + 1])
            merge(arr, L, mid, R);

        printArray(arr);
        System.out.println();

    }

    private void merge(int[] arr, int L, int mid, int R) {

        int aux[] = new int[R - L + 1];

        for (int i = L; i <= R; i++) {

            aux[i - L] = arr[i];
        }

        int i = L;
        int j = mid + 1;

        for (int k = L; k <= R; k++) {

            if (i > mid) {
                arr[k] = aux[j - L];
                j++;
            } else if (j > R) {
                arr[k] = aux[i - L];
                i++;
            } else if (aux[i - L] < aux[j - L]) {
                arr[k] = aux[i - L];
                i++;
            } else if (aux[i - L] > aux[j - L]) {
                arr[k] = aux[j - L];
                j++;
            } else { // 相等情况，
                arr[k] = aux[j - L];
                j++;
            }

        }
    }

五、快速排序

    /**
     * 快速排序
     */
    public void quickSorted(int arr[]) {

        int n = arr.length - 1;

        quickSorted(arr, 0, n);
    }

    private void quickSorted(int[] arr, int L, int R) {

        if (L >= R)
            return;

        // 单路
//        int p1 = partioner(arr, L, R);
//
//        quickSorted(arr, L, p1 - 1);
//        quickSorted(arr, p1 + 1, R);

        // 双路
        int p2 = partioner2(arr, L, R);

        quickSorted(arr, L, p2 - 1);
        quickSorted(arr, p2 + 1, R);
    }

    // 单路
    private int partioner(int[] arr, int L, int R) {

        int v = arr[L];
        int j = L;

        for (int i = j + 1; i <= R; i++) {

            if (arr[i] < v) {
                swap(arr, i, j + 1);
                j++;

            }
        }
        swap(arr, j, L);

        return j;
    }

    // 双路
    private int partioner2(int[] arr, int L, int R) {

        int v = arr[L];

        int j = L + 1;
        int k = R;

        while (true) {

            while (j <= R && arr[j] < v)
                j++;
            while (k >= L + 1 && arr[k] > v)
                k--;
            if (k < j)
                break;

            swap(arr, j, k);

        }

        swap(arr, L, k);

        return k;
    }

    // 三路
    public void quickSorted3(int arr[]) {

        int n = arr.length - 1;

        quickSorted3(arr, 0, n);
    }

    private void quickSorted3(int[] arr, int L, int R) {

        if (L >= R)
            return;

        int v = arr[L];

        int lt = L;
        int gt = R + 1;
        int i = lt + 1;

        while (i < gt) {

            if (arr[i] < v) {
                swap(arr, lt + 1, i);
                i++;
                lt++;
            } else if (arr[i] > v) {
                swap(arr, i, gt - 1);
                gt--;
            } else
                i++;
        }
        swap(arr, lt, L);

        quickSorted3(arr, L, lt - 1);
        quickSorted3(arr, gt, R);
    }

六、堆排序

    /**
     * 堆排序
     */
    public void heapSorted(int arr[]) {

        int n = arr.length;

        int pos = (n - 1) / 2;
        for (int i = pos; i >= 0; i--) {
            shiftDown(arr, i, n);
        }

        for (int i = n - 1; i > 0; i--) {

            swap(arr, 0, i);
            shiftDown(arr, 0, i);
        }

    }

    private void shiftDown(int arr[], int pos, int n) {

        while (pos * 2 + 1 < n) {

            int k = (pos * 2) + 1;
            if (k + 1 < n && arr[k + 1] > arr[k])
                k = k + 1;
            if (arr[pos] < arr[k]) {
                swap(arr, k, pos);
                pos = k;
            } else
                break;
        }
    }

七、希尔排序

    /**
     * 希尔排序
     */
    public void shellSortd(int arr[]) {

        int n = arr.length;

        int i, j, h;
        int tmp;

        for (h = n / 2; h > 0; h = h / 2) {
            for (i = h; i < n; i++) {
                tmp = arr[i];
                for (j = i - h; j >= 0; j = j - h) {
                    if (tmp < arr[j])
                        arr[j + h] = arr[j];
                    else
                        break;
                }
                arr[j + h] = tmp;

            }
        }
    }