五种常见排序算法的java实现

下面展示了五种排序算法：

1.冒泡排序算法

2.快速排序算法

3.归并排序算法

4.插入排序算法

5.选择排序算法

package suanfa;


public class InsertionSort {


    public static void main(String[] args) {

        Comparable[] A = new Comparable[]{5, 2, 4, 6, 11, 3, 7, 9};

        bubbleSort(A);
        A = new Comparable[]{5, 2, 4, 6, 11, 3, 7, 9};
        quickSort(A);
        A = new Comparable[]{5, 2, 4, 6, 11, 3, 7, 9};
        mergeSort(A);
        A = new Comparable[]{5, 2, 4, 6, 11, 3, 7, 9};
        insertionSort(A);
        A = new Comparable[]{5, 2, 4, 6, 11, 3, 7, 9};
        selectSort(A);

    }

    private static void printArray(Comparable[] A) {
        for (Comparable a : A) {
            System.out.print(a + "|");
        }
        System.out.println();
    }

    /**
     * 插入排序
     *
     * @param A
     */
    public static void insertionSort(Comparable[] A) {

        for (int j = 1; j < A.length; j++) {
            Comparable key = A[j];
            // 插入已排序的A[0..j-1]
            int i = j - 1;
            while (i >= 0 && A[i].compareTo(key) > 0) {
                A[i + 1] = A[i];
                i = i - 1;
            }
            A[i + 1] = key;
            printArray(A);
        }

    }

    /**
     * 冒泡排序
     *
     * @param A
     */
    public static void bubbleSort(Comparable[] A) {
        for (int i = 0; i < A.length; i++) {
            printArray(A);
            for (int j = i + 1; j < A.length; j++) {
                if (A[i].compareTo(A[j]) < 0) {
                    Comparable key = A[i];
                    A[i] = A[j];
                    A[j] = key;
                }
            }

        }
    }

    /**
     * 选择排序
     */
    public static void selectSort(Comparable[] A) {
        for (int i = 0; i < A.length; i++) {
            int k = i;
            for (int j = i + 1; j < A.length; j++) {
                if (A[k].compareTo(A[j]) < 0) {
                    k = j;
                }
            }
            if (k != i) {
                Comparable key = A[i];
                A[i] = A[k];
                A[k] = key;
            }
            printArray(A);

        }

    }

    /**
     * 快速排序
     *
     * @param A
     */
    public static void quickSort(Comparable[] A) {
        quickSort0(A, 0, A.length - 1);
    }

    private static void quickSort0(Comparable[] a, int low, int high) {
        //1,找到递归算法的出口
        if (low > high) {
            return;
        }
        //2, 存
        int i = low;
        int j = high;
        //3,key
        Comparable key = a[low];
        //4，完成一趟排序
        while (i < j) {
            //4.1 ，从右往左找到第一个小于key的数
            while (i < j && a[j].compareTo(key) > 0) {
                j--;
            }
            // 4.2 从左往右找到第一个大于key的数
            while (i < j && a[i].compareTo(key) <= 0) {
                i++;
            }
            //4.3 交换
            if (i < j) {
                Comparable p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
            printArray(a);

        }
        // 4.4，调整key的位置
        Comparable p = a[i];
        a[i] = a[low];
        a[low] = p;
        //5, 对key左边的数快排
        quickSort0(a, low, i - 1);
        //6, 对key右边的数快排
        quickSort0(a, i + 1, high);


    }


    /**
     * 归并排序
     *
     * @param A
     */
    public static void mergeSort(Comparable[] A) {
        mergeSort0(A, 1, A.length);
    }

    //p=r-1
    //q=r-1
    private static void mergeSort0(Comparable[] A, int p, int r) {
        if (p < r) {
            int q = (p + r) / 2;
            mergeSort0(A, p, q);
            mergeSort0(A, q + 1, r);
            System.out.println("p=" + p + ";q=" + q + ";r=" + r);
            printArray(A);
            merge(A, p, q, r);
            printArray(A);
            System.out.println("************");
        }
    }


    //p=r-1
    //q=r-1
    private static void merge(Comparable[] A, int p, int q, int r) {

        int n1 = q - p + 1;//[p,q]
        int n2 = r - q;//[q+1,r]
        Comparable[] L = new Comparable[n1];
        for (int i = 0; i < n1; i++) {
            L[i] = A[p + i - 1];
        }
        Comparable[] R = new Comparable[n2];
        for (int j = 0; j < n2; j++) {
            R[j] = A[q + j];
        }
        int i = 0;
        int j = 0;
        for (int k = p - 1; k < r; k++) {
            if ((i < n1) && (j < n2)) {
                if (L[i].compareTo(R[j]) > 0) {
                    A[k] = L[i];
                    i++;
                } else {
                    A[k] = R[j];
                    j++;
                }
            } else if ((i == n1) && (j < n2)) {
                A[k] = R[j];
                j++;
            } else if ((i < n1) && (j == n2)) {
                A[k] = L[i];
                i++;
            }
        }

    }


}