Java排序總結

測試的資料

    public static Integer[] sort = new Integer[]{0, 3, 2, 1, 9, 8, 5, 6, 7, 4};

1. 氣泡排序

大小比較函式

    public static void rightBig(Integer[] sort, int left, int right) {
        if (sort[left] > sort[right]) {
            Integer temp = sort[left];
            sort[left] = sort[right];
            sort[right] = temp;
        }
    }
 

實現：

    /**
     * 冒泡是 左右相鄰比較
     * <p>
     * 時間複雜度  O(n²) 。
     *
     * @param args
     */
    public static void main(String[] args) {

        //second:i中的sort.length-1 是因為如果10個數 9個大數已經冒泡上去了那麼最後一個就是最小的 不需要再排序了
        for (int i = 0; i < sort.length - 1; i++) {
            //first：從內層迴圈分析
 

            //10個數  相鄰的兩個數 進行比較 迴圈一次 則把最大的數冒泡到右邊；
            //sort.length - 1是防止 陣列越界 最後一個不需要後一個數作對比
            for (int j = 0; j < (sort.length - 1 - i); j++) {
                rightBig(sort, j, j + 1);
            }
        }
        System.out.println("value:" + Arrays.asList(sort));
    }

2. 選擇排序

實現：

/**
     * 選擇排序。   一個位置 L與所有的位置All_L，一次進行對比 和交換。一輪對比完，那個位置的值既最小
     * <p>
     * 時間複雜度  O(n²) 。 (n-1)次迴圈*(n)次迴圈
     *
     * @param args
     */
    public static void main(String[] args) {

        //第一層迴圈確定  位置L
        for (int i = 0; i < sort.length - 1; i++) {
            //All_L 的的迴圈。需要在位置L的後邊開始
            for (int j = i + 1; j < sort.length; j++) {
                rightBig(sort, i, j);
            }
        }
        System.out.println("value:" + Arrays.asList(sort));
    }

3. 插入排序

實現：

    public static void insertsort(Integer arr[]) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {//注意[0,i-1]都是有序的。如果待插入元素比arr[i-1]還大則無需再與[i-1]前面的元素進行比較了，反之則進入if語句
                int temp = arr[i];
                int j;
                for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
                    arr[j + 1] = arr[j];//把比temp大或相等的元素全部往後移動一個位置
                }
                arr[j + 1] = temp;//把待排序的元素temp插入騰出位置的(j+1)
            }
        }

    }

    public static void main(String[] args) {
        System.out.println("排序之前：" + Arrays.asList(sort));
        insertsort(sort);
        System.out.println("排序之後：" + Arrays.asList(sort));
    }

4.希爾排序

實現：

    /**
     * 希爾排序
     *
     * @param arrays 需要排序的序列
     */
    public static void sort(Integer[] arrays) {
        if (arrays == null || arrays.length <= 1) {
            return;
        }
        //增量
        int incrementNum = arrays.length / 2;
        while (incrementNum >= 1) {
            for (int i = 0; i < arrays.length; i++) {
                //進行插入排序
                for (int j = i; j < arrays.length - incrementNum; j = j + incrementNum) {
                    if (arrays[j] > arrays[j + incrementNum]) {
                        int temple = arrays[j];
                        arrays[j] = arrays[j + incrementNum];
                        arrays[j + incrementNum] = temple;
                    }
                }
            }
            //設定新的增量
            incrementNum = incrementNum / 2;
        }
    }

    public static void main(String[] args) {
        sort(sort);
        System.out.println("value:" + Arrays.asList(sort));
    }

5.快速排序

實現：

    public static void printArray(int[] array) {
        System.out.print("{");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
            if (i < array.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("}");
    }

    public static void quickSort(int a[], int start, int end) {
        int i, j;
        i = start;
        j = end;
        if ((a == null) || (a.length <= 1))
            return;

        while (i < j) {//查詢基準點下標
            while (i < j && a[j] > a[i])
                j--;
            if (i < j) { // 右側掃描，找出第一個比key小的，交換位置
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
            while (i < j && a[i] < a[j])
                // 左側掃描（此時a[j]中儲存著key值）
                i++;
            if (i < j) { // 找出第一個比key大的，交換位置
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        if (i - start > 1) { // 遞迴呼叫，把key前面的完成排序
            quickSort(a, 0, i - 1);
        }
        if (end - j > 1) {
            quickSort(a, j + 1, end); // 遞迴呼叫，把key後面的完成排序
        }
    }

    public static void main(String[] args) {
        int[] array = {-7,-1,9, 6, 5, 4, 1, 0,  8, 7, 3, 2, -2, -3};

        System.out.print("Before sort:");
        printArray(array);

        quickSort(array, 0, array.length - 1);

        System.out.print("After sort:");
        printArray(array);
    }

6.二分查詢（折半插入查詢）

實現：

    public static void main(String[] args) {
        int[] a = {4, 2, 1, 6, 3, 6, 0, -5, 1, 1};
        int i, j;
        int low, high, mid;
        int temp;
        for (i = 1; i < a.length; i++) {
            temp = a[i];
            low = 0;
            high = i - 1;
            //定位 前面那些位置 那個位置應該是temp應該在的位置。
            while (low <= high) {
                //臨界條件是   low<=temp<=high low和high相連的時候。
                //既 low>high的時候 over了
                //low high 相鄰的時候  low=mid+1; low==high;->a[mid=high]>temp->high=high-1. 所以high再+1.找到temp放入的位置。
                // low>high的時候 那麼high+1 的位置就是 temp應該呆的位置。

                //一半的一半的 和 temp對比。
                mid = (low + high) / 2;
                if (a[mid] > temp)
                    high = mid - 1;
                else
                    low = mid + 1;

            }
            //定位的位置都向後挪動一個位置
            for (j = i - 1; j > high; j--)
                a[j + 1] = a[j];
            //temp弄進來即可。
            a[high + 1] = temp;
        }
        for (i = 0; i < 10; i++) {
            System.out.printf("%d  ", a[i]);
        }
    }