Java常用算法總結（轉）

交換排序

冒泡排序

將最后一個元素與倒數第二個元素對比，如果最后一個元素比倒數第二個小，則交換兩個元素的位置，再用倒數第二個元素與倒數第三個元數對比，直到比到第一個元素，這樣經過第一趟排序后得到第一個最小元素。如此反復幾過N（N=length-1）次后可得到排序結果。

package sort;

import java.util.Comparator;

/**
 * 冒泡排序算法
 * @author jzj
 * @date 2009-12-9
 *
 * @param <E>
 */
publicclass BubbleSort<E extends Comparable<E>> extends Sort<E> {

    /**
     * 排序算法的實現，對數組中指定的元素進行排序
     * @param array 待排序的數組
     * @param from 從哪里開始排序
     * @param end 排到哪里
     * @param c 比較器
     */
    publicvoid sort(E[] array, int from, int end, Comparator<E> c) {
        //需array.length - 1輪比較
        for (int k = 1; k < end - from + 1; k++) {
            //每輪循環中從最后一個元素開始向前起泡，直到i=k止，即i等於輪次止
            for (int i = end - from; i >= k; i--) {
                //按照一種規則（后面元素不能小於前面元素）排序
                if (c.compare(array[i], array[i - 1]) < 0) {
                    //如果后面元素小於了（當然是大於還是小於要看比較器實現了）前面的元素，則前后交換
                    swap(array, i, i - 1);
                }
            }
        }
    }

    /**
    * 測試
    * @param args
    */
    publicstaticvoid main(String[] args) {
        Integer[] intgArr = { 7, 2, 4, 3, 12, 1, 9, 6, 8, 5, 11, 10 };
        BubbleSort<Integer> sort = new BubbleSort<Integer>();
        BubbleSort.testSort(sort, intgArr);
        BubbleSort.testSort(sort, null);
    }
}

快速排序

快速排序采用了分治法的思想，把大的問題分解為同類型的小問題。 一般分如下步驟： 1）選擇一個中樞元素（有很多選法，我的實現里使用第一個元素為中樞的簡單方法） 2）以該中樞元素為基准點，將小於中樞的元素放在中樞后集合的前部分，比它大的在集合后部分，待集合基本排序完成后（此時前部分元素小於后部分元素），把中樞元素放在合適的位置。 3）根據中樞元素最后確定的位置，把數組分成三部分，左邊的，右邊的，樞紐元素自己，對左邊的，右邊的分別遞歸調用快速排序算法即可。
這里的重點與難點在於第二步，實現的方式有很多種，我這里實現了三種。 第一種實現（partition1方法）： 以第一個元素為中樞元素，在中樞元素后面集合中從前往后尋找第一個比中樞元素小的元素，並與第一個元素交換，然后從剩余的元素中尋找第二個比中樞元素小的 元素，並與第二位元素交換，這樣直到所有小於中樞元素找完為止，並記下最后一次放置小於中樞的元素位置minIndex（即小於中樞與大於中樞的分界）， 並將中樞元素與minIndex位置元素互換，然后對中樞元素兩邊的序列進行同樣的操作。 此種實現最為簡潔，處理過程中不需要把中樞元素移來移去，只是在其它元素完成基本排序后（前部分小於后部分元素）再把中樞元素放置到適當的位置 第二種實現（partition2方法）： 以第一個元素為中樞元素，剛開始時使用低指針指向中樞元素。當中樞元素在低指針位置時，此時我們判斷高指針指向的元素是否小於中樞元素，如果大於中樞元素 則高指針繼續向頭移動，如果小於則與中樞元素交換，此時中樞元素被移到了高指針位置；當中樞元素在高指針位置時，我們此時判斷低指針指向的元素是否大於中 樞元素，如果小於中樞元素則低指針繼續向尾移動，如果大於則與中樞元素交換，此時中樞元素又回到了低指針位置；這時是拿高還是低指針所指向的元素與中樞比 較時根據前面邏輯來處理，直到高低指針指向同一位置則完成一輪排序，然后再對中樞元素兩邊的序列進行同樣的操作直到排序完成 此種實現邏輯比較好理解，中樞元素的永遠在低指針或指針所指向的位置，每次找到需處理的元 素后，要與中樞交換，中樞就像皮球一樣從這里踢到那里，又從那里踢到這里。但此種實現會頻繁地交換中樞元素，性能可能不如第一種 第三種實現（partition3方法）： 此種方式與前兩種方式不太一樣，同時移動高低指針，低指針向尾找出大於等於中樞的元素，而高向頭找出小於中樞的元素，待兩者都找出后交換高低指針所指向的 元素，直到高低指針指向同一位置止，然后比較中樞與高低指針所指向的元素大小，如果中樞元素大，則直接與高低指針元素交換，如果中樞元素小於等於高低指針 元素，則中樞元素與高低指針前一元素交換，完成一輪比較，然后再對中樞元素兩邊的序列進行同樣的操作直到排序完成

此種方式有點難度，在移動元素時要注意的是：與中樞相等的元素也要向集合后部移動，不然的話如[3,3,0,3,3]第一輪排序結果不准確，雖然最后結果 正確。當中樞后面的元素集合移動完成后，還得要把中樞元素放置在集合中的合適位置，這就需要找准集合中前部分與后部分的邊界，最后只能把中樞元素與最后一 個小於中樞的元素進位置互換。但此種實現方式與第一種有點像，也不需要把中樞元素調來調去的，而是待后面集合排序完成后將中樞放入適當位置

package sort;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 快速排序算法
 * @author jzj
 * @date 2009-12-9
 *
 * @param <E>
 */
publicclass QuickSort<E extends Comparable<E>> extends Sort<E> {

    /**
     * 排序算法的實現，對數組中指定的元素進行排序
     * @param array 待排序的數組
     * @param from 從哪里開始排序
     * @param end 排到哪里
     * @param c 比較器
     */
    publicvoid sort(E[] array, int from, int end, Comparator<E> c) {
        quickSort(array, from, end, c);
    }

    /**
     * 遞歸快速排序實現
     * @param array 待排序數組
     * @param low 低指針
     * @param high 高指針
     * @param c 比較器
     */
    privatevoid quickSort(E[] array, int low, int high, Comparator<E> c) {
        /*
         * 如果分區中的低指針小於高指針時循環；如果low=higth說明數組只有一個元素，無需再處理；
         * 如果low > higth，則說明上次樞紐元素的位置pivot就是low或者是higth，此種情況
         * 下分區不存，也不需處理
         */
        if (low < high) {
            //對分區進行排序整理
            int pivot = partition1(array, low, high, c);
            /*
             * 以pivot為邊界，把數組分成三部分[low, pivot - 1]、[pivot]、[pivot + 1, high]
             * 其中[pivot]為樞紐元素，不需處理，再對[low, pivot - 1]與[pivot + 1, high]
             * 各自進行分區排序整理與進一步分區
             */
            quickSort(array, low, pivot - 1, c);
            quickSort(array, pivot + 1, high, c);
        }

    }

    /**
     * 實現一
     *
     * @param array 待排序數組
     * @param low 低指針
     * @param high 高指針
     * @param c 比較器
     * @return int 調整后中樞位置
     */
    privateint partition1(E[] array, int low, int high, Comparator<E> c) {
        E pivotElem = array[low];//以第一個元素為中樞元素
        //從前向后依次指向比中樞元素小的元素，剛開始時指向中樞，也是小於與大小中樞的元素的分界點
        int border = low;

        /*
         * 在中樞元素后面的元素中查找小於中樞元素的所有元素，並依次從第二個位置從前往后存放
         * 注，這里最好使用i來移動，如果直接移動low的話，最后不知道數組的邊界了，但后面需要
         * 知道數組的邊界
         */
        for (int i = low + 1; i <= high; i++) {
            //如果找到一個比中樞元素小的元素
            if (c.compare(array[i], pivotElem) < 0) {
                swap(array, ++border, i);//border前移，表示有小於中樞元素的元素
            }
        }
        /*
         * 如果border沒有移動時說明說明后面的元素都比中樞元素要大，border與low相等，此時是
         * 同一位置交換，是否交換都沒關系；當border移到了high時說明所有元素都小於中樞元素，此
         * 時將中樞元素與最后一個元素交換即可，即low與high進行交換，大的中樞元素移到了 序列最
         * 后；如果 low <minIndex< high，表 明中樞后面的元素前部分小於中樞元素，而后部分大於
         * 中樞元素，此時中樞元素與前部分數組中最后一個小於它的元素交換位置，使得中樞元素放置在
         * 正確的位置
         */
        swap(array, border, low);
        return border;
    }

    /**
     * 實現二
     *
     * @param array 待排序數組
     * @param low 待排序區低指針
     * @param high 待排序區高指針
     * @param c 比較器
     * @return int 調整后中樞位置
     */
    privateint partition2(E[] array, int low, int high, Comparator<E> c) {
        int pivot = low;//中樞元素位置，我們以第一個元素為中樞元素
        //退出條件這里只可能是 low = high
        while (true) {
            if (pivot != high) {//如果中樞元素在低指針位置時，我們移動高指針
                //如果高指針元素小於中樞元素時，則與中樞元素交換
                if (c.compare(array[high], array[pivot]) < 0) {
                    swap(array, high, pivot);
                    //交換后中樞元素在高指針位置了
                    pivot = high;
                } else {//如果未找到小於中樞元素，則高指針前移繼續找
                    high--;
                }
            } else {//否則中樞元素在高指針位置
                //如果低指針元素大於中樞元素時，則與中樞元素交換
                if (c.compare(array[low], array[pivot]) > 0) {
                    swap(array, low, pivot);
                    //交換后中樞元素在低指針位置了
                    pivot = low;
                } else {//如果未找到大於中樞元素，則低指針后移繼續找
                    low++;
                }
            }
            if (low == high) {
                break;
            }
        }
        //返回中樞元素所在位置，以便下次分區
        return pivot;
    }

    /**
     * 實現三
     *
     * @param array 待排序數組
     * @param low 待排序區低指針
     * @param high 待排序區高指針
     * @param c 比較器
     * @return int 調整后中樞位置
     */
    privateint partition3(E[] array, int low, int high, Comparator<E> c) {
        int pivot = low;//中樞元素位置，我們以第一個元素為中樞元素
        low++;
        //----調整高低指針所指向的元素順序，把小於中樞元素的移到前部分，大於中樞元素的移到后面部分
        //退出條件這里只可能是 low = high

        while (true) {
            //如果高指針未超出低指針
            while (low < high) {
                //如果低指針指向的元素大於或等於中樞元素時表示找到了，退出，注：等於時也要后移
                if (c.compare(array[low], array[pivot]) >= 0) {
                    break;
                } else {//如果低指針指向的元素小於中樞元素時繼續找
                    low++;
                }
            }

            while (high > low) {
                //如果高指針指向的元素小於中樞元素時表示找到，退出
                if (c.compare(array[high], array[pivot]) < 0) {
                    break;
                } else {//如果高指針指向的元素大於中樞元素時繼續找
                    high--;
                }
            }
            //退出上面循環時 low = high
            if (low == high) {
                break;
            }

            swap(array, low, high);
        }

        //----高低指針所指向的元素排序完成后，還得要把中樞元素放到適當的位置
        if (c.compare(array[pivot], array[low]) > 0) {
            //如果退出循環時中樞元素大於了低指針或高指針元素時，中樞元素需與low元素交換
            swap(array, low, pivot);
            pivot = low;
        } elseif (c.compare(array[pivot], array[low]) <= 0) {
            swap(array, low - 1, pivot);
            pivot = low - 1;
        }

        //返回中樞元素所在位置，以便下次分區
        return pivot;
    }

    /**
    * 測試
    * @param args
    */
    publicstaticvoid main(String[] args) {
        Integer[] intgArr = { 3, 1, 1, 1, 1, 1, 1 };
        QuickSort<Integer> sort = new QuickSort<Integer>();
        QuickSort.testSort(sort, intgArr);
        QuickSort.testSort(sort, null);
    }
}

歸並排序

package sort;

import java.lang.reflect.Array;
import java.util.Comparator;

/**
 * 歸並排序算法
 * @author jzj
 * @date 2009-12-11
 *
 * @param <E>
 */
publicclass MergeSort<E extends Comparable<E>> extends Sort<E> {

    /**
     * 排序算法的實現，對數組中指定的元素進行排序
     * @param array 待排序的數組
     * @param from 從哪里開始排序
     * @param end 排到哪里
     * @param c 比較器
     */
    publicvoid sort(E[] arr, int from, int end, Comparator<E> c) {
        partition(arr, from, end, c);
    }

    /**
     * 遞歸划分數組
     * @param arr
     * @param from
     * @param end
     * @param c void
     */
    privatevoid partition(E[] arr, int from, int end, Comparator<E> c) {
        //划分到數組只有一個元素時才不進行再划分
        if (from < end) {
            //從中間划分成兩個數組
            int mid = (from + end) / 2;
            partition(arr, from, mid, c);
            partition(arr, mid + 1, end, c);
            //合並划分后的兩個數組
            merge(arr, from, end, mid, c);
        }
    }

    /**
     * 數組合並，合並過程中對兩部分數組進行排序
     * 前后兩部分數組里是有序的
     * @param arr
     * @param from
     * @param end
     * @param mid
     * @param c void
     */
    privatevoid merge(E[] arr, int from, int end, int mid, Comparator<E> c) {
        E[] tmpArr = (E[]) Array.newInstance(arr[0].getClass(), end - from + 1);
        int tmpArrIndex = 0;//指向臨時數組
        int part1ArrIndex = from;//指向第一部分數組
        int part2ArrIndex = mid + 1;//指向第二部分數組

        //由於兩部分數組里是有序的，所以每部分可以從第一個元素依次取到最后一個元素，再對兩部分
        //取出的元素進行比較。只要某部分數組元素取完后，退出循環
        while ((part1ArrIndex <= mid) && (part2ArrIndex <= end)) {
            //從兩部分數組里各取一個進行比較，取最小一個並放入臨時數組中
            if (c.compare(arr[part1ArrIndex], arr[part2ArrIndex]) < 0) {
                //如果第一部分數組元素小，則將第一部分數組元素放入臨時數組中，並且臨時數組指針
                //tmpArrIndex下移一個以做好下次存儲位置准備，前部分數組指針part1ArrIndex
                //也要下移一個以便下次取出下一個元素與后部分數組元素比較
                tmpArr[tmpArrIndex++] = arr[part1ArrIndex++];
            } else {
                //如果第二部分數組元素小，則將第二部分數組元素放入臨時數組中
                tmpArr[tmpArrIndex++] = arr[part2ArrIndex++];
            }
        }
        //由於退出循環后，兩部分數組中可能有一個數組元素還未處理完，所以需要額外的處理，當然不可
        //能兩部分數組都有未處理完的元素，所以下面兩個循環最多只有一個會執行，並且都是大於已放入
        //臨時數組中的元素
        while (part1ArrIndex <= mid) {
            tmpArr[tmpArrIndex++] = arr[part1ArrIndex++];
        }
        while (part2ArrIndex <= end) {
            tmpArr[tmpArrIndex++] = arr[part2ArrIndex++];
        }

        //最后把臨時數組拷貝到源數組相同的位置
        System.arraycopy(tmpArr, 0, arr, from, end - from + 1);
    }

    /**
     * 測試
     * @param args
     */
    publicstaticvoid main(String[] args) {
        Integer[] intgArr = { 5, 9, 1, 4, 1, 2, 6, 3, 8, 0, 7 };
        MergeSort<Integer> insertSort = new MergeSort<Integer>();
        Sort.testSort(insertSort, intgArr);
        Sort.testSort(insertSort, null);
    }
}

基數排序

基數排序的主要思路是,將所有待比較數值(注意,必須是正整數)統一為同樣的數位長度,數位較短的數前面補零. 然后, 從最低位開始, 依次進行一次穩定排序.這樣從最低位排序一直到最高位排序完成以后, 數列就變成一個有序序列.

它的理論比較容易理解，但實現卻有一點繞。

package sort;

import java.util.Arrays;

publicclass RadixSort {

    /**
     * 取數x上的第d位數字
     * @param x 數
     * @param d 第幾位，從低位到高位
     * @return
     */
    publicint digit(long x, long d) {

        long pow = 1;
        while (--d > 0) {
            pow *= 10;
        }
        return (int) (x / pow % 10);
    }

    /**
     * 基數排序實現，以升序排序（下面程序中的位記錄器count中，從第0個元素到第9個元素依次用來
     * 記錄當前比較位是0的有多少個..是9的有多少個數，而降序時則從第0個元素到第9個元素依次用來
     * 記錄當前比較位是9的有多少個..是0的有多少個數）
     * @param arr 待排序數組
     * @param digit 數組中最大數的位數
     * @return
     */
    publiclong[] radixSortAsc(long[] arr) {
        //從低位往高位循環
        for (int d = 1; d <= getMax(arr); d++) {
            //臨時數組，用來存放排序過程中的數據
            long[] tmpArray = newlong[arr.length];
            //位記數器，從第0個元素到第9個元素依次用來記錄當前比較位是0的有多少個..是9的有多少個數
            int[] count = newint[10];
            //開始統計0有多少個，並存儲在第0位，再統計1有多少個，並存儲在第1位..依次統計到9有多少個
            for (int i = 0; i < arr.length; i++) {
                count[digit(arr[i], d)] += 1;
            }
            /*
             * 比如某次經過上面統計后結果為：[0, 2, 3, 3, 0, 0, 0, 0, 0, 0]則經過下面計算后 結果為：
             * [0, 2, 5, 8, 8, 8, 8, 8, 8, 8]但實質上只有如下[0, 2, 5, 8, 0, 0, 0, 0, 0, 0]中
             * 非零數才用到，因為其他位不存在，它們分別表示如下：2表示比較位為1的元素可以存放在索引為1、0的
             * 位置，5表示比較位為2的元素可以存放在4、3、2三個(5-2=3)位置，8表示比較位為3的元素可以存放在
             * 7、6、5三個(8-5=3)位置
             */
            for (int i = 1; i < 10; i++) {
                count[i] += count[i - 1];
            }

            /*
             * 注，這里只能從數組后往前循環，因為排序時還需保持以前的已排序好的 順序，不應該打
             * 亂原來已排好的序，如果從前往后處理，則會把原來在前面會擺到后面去，因為在處理某個
             * 元素的位置時，位記數器是從大到到小（count[digit(arr[i], d)]--）的方式來處
             * 理的，即先存放索引大的元素，再存放索引小的元素，所以需從最后一個元素開始處理。
             * 如有這樣的一個序列[212,213,312]，如果按照從第一個元素開始循環的話，經過第一輪
             * 后（個位）排序后，得到這樣一個序列[312,212,213]，第一次好像沒什么問題，但問題會
             * 從第二輪開始出現，第二輪排序后，會得到[213,212,312]，這樣個位為3的元素本應該
             * 放在最后，但經過第二輪后卻排在了前面了，所以出現了問題
             */
            for (int i = arr.length - 1; i >= 0; i--) {//只能從最后一個元素往前處理
                //for (int i = 0; i < arr.length; i++) {//不能從第一個元素開始循環
                tmpArray[count[digit(arr[i], d)] - 1] = arr[i];
                count[digit(arr[i], d)]--;
            }

            System.arraycopy(tmpArray, 0, arr, 0, tmpArray.length);
        }
        return arr;
    }

    /**
     * 基數排序實現，以降序排序（下面程序中的位記錄器count中，從第0個元素到第9個元素依次用來
     * 記錄當前比較位是0的有多少個..是9的有多少個數，而降序時則從第0個元素到第9個元素依次用來
     * 記錄當前比較位是9的有多少個..是0的有多少個數）
     * @param arr 待排序數組
     * @return
     */
    publiclong[] radixSortDesc(long[] arr) {
        for (int d = 1; d <= getMax(arr); d++) {
            long[] tmpArray = newlong[arr.length];
            //位記數器，從第0個元素到第9個元素依次用來記錄當前比較位是9的有多少個..是0的有多少個數
            int[] count = newint[10];
            //開始統計0有多少個，並存儲在第9位，再統計1有多少個，並存儲在第8位..依次統計
            //到9有多少個，並存儲在第0位
            for (int i = 0; i < arr.length; i++) {
                count[9 - digit(arr[i], d)] += 1;
            }

            for (int i = 1; i < 10; i++) {
                count[i] += count[i - 1];
            }

            for (int i = arr.length - 1; i >= 0; i--) {
                tmpArray[count[9 - digit(arr[i], d)] - 1] = arr[i];
                count[9 - digit(arr[i], d)]--;
            }

            System.arraycopy(tmpArray, 0, arr, 0, tmpArray.length);
        }
        return arr;
    }

    privateint getMax(long[] array) {
        int maxlIndex = 0;
        for (int j = 1; j < array.length; j++) {
            if (array[j] > array[maxlIndex]) {
                maxlIndex = j;
            }
        }
        return String.valueOf(array[maxlIndex]).length();
    }

    publicstaticvoid main(String[] args) {
        long[] ary = newlong[] { 123, 321, 132, 212, 213, 312, 21, 223 };
        RadixSort rs = new RadixSort();
        System.out.println("升 - " + Arrays.toString(rs.radixSortAsc(ary)));

        ary = newlong[] { 123, 321, 132, 212, 213, 312, 21, 223 };
        System.out.println("降 - " + Arrays.toString(rs.radixSortDesc(ary)));
    }
}

時間復雜度與空間復雜度對比表

 

原文：http://jiangzhengjun.iteye.com/blog/547735