java排序(整理)

冒泡排序（面試都要問的算法）

　　1、基本思想：每次比較相鄰的兩個 元素，按需調整順序

 

　　2、題目：要求將 12 35 99 18 76 這 5 個數進行從大到小排序

 

　　3、思路：

　　　　（1）先比較第 1 位和第 2 位的大小，12<35，由於但願越小越靠後，因此要調整二者順序，交換後的結果：35 12 99 18 76

　　　　（2）如今比較第 2 位和第 3 位的大小，12<99，因此須要交換位置，交換後的結果爲：35 99 12 18 76

　　　　（3）接着比較第 3 位和第 4 位的大小，12<18，交換後的結果爲：35 99 18 12 76

　　　　（4）最後比較第 4 位和第 5 位的大小，12<76，交換後的結果爲：35 99 18 76 12

              （5）通過 4 次後咱們發現 5 個數中最小的一個數已經就位，每將一個數歸位咱們稱其爲「一趟」；

　　　　（6）如今咱們開始第二趟，目標將第 2 小的數歸位，根據以前邏輯，仍是從第 1 個數和第 2 個數開始比較上：

          　　35 99 18 76 12 --①--> 99 35 18 76 12 --②--> 99 35 18 76 12 --③--> 99 35 76 18 12

         　　 在第一趟比較就知道第 5 位是最小的，因此第 4 位不用和第 5 位比較，這一趟只需比較 3 次

　　　　（7）第3趟：99 35 76 18 12 --> 99 35 76 18 12 --> 99 76 35 18 12 （比較 2 次）

　　　　（8）第4趟：99 76 35 18 12 --> 99 76 35 18 12 ,有4個數已經就位，那麼最後一個數無須比較，它就是最大的

 

　　【總結】若是有 n 個數進行排序，只需將 n-1 個數歸位，即要進行 n-1 趟操做，而每一趟開始都從第 1 位進行相鄰的兩個數 進行比較，將小的那個數放在後面，已經歸位的就不用進行比較。

  

　　【特色】冒泡算法的核心部分是雙重嵌套循環，能夠看出時間複雜度是 O(N²)，這是一個很是高的時間複雜度。

 

這裏使用Java給出簡單的算法過程。

/**
     * 冒泡排序，從小到大
     * @param args
     */
     public static void main(String args[]){
         int nums[] = new int[] { 12, 35, 99, 18, 76,2,4,5,6,77,8,9 };   
         
         for(int i=0;i<nums.length-1;i++){
             //int j=0;j<nums.length-1;j++   
             //int j=0;j<nums.length-1-i;j++
             //第二種，優與第一種
             for(int j=0;j<nums.length-1-i;j++){
                 int f=nums[j];//第一個數
                 int s=nums[j+1];//第二個數
                 if(s<f){
                     int temp=f;
                     nums[j]=nums[j+1];
                     nums[j+1]=temp;
                 }
             }
         }
         output(nums);
     }
     
     public static void output(int num[]){
         for(int n:num){
             System.out.print(n +" ");
         }
     }

快速排序（見證亞當和夏娃的愛情之旅）

　　1、場景：對 6 1 2 7 9 3 4 5 10 8 這 10 個數進行排序

 

　　2、思路：

　　　　先找一個基準數（一個用來參照的數），爲了方便，咱們選最左邊的 6，但願將 >6 的放到 6 的右邊，<6 的放到 6 左邊。如：3 1 2 5 4 6 9 7 10 8

　　　　先假設須要將 6 挪到的位置爲 k，k 左邊的數 <6，右邊的數 >6

　　　　（1）咱們先從初始數列「6 1 2 7 9 3 4 5 10 8 」的兩端開始「探測 」，先從右邊往左找一個 <6 的數，再從左往右找一個 >6 的數，而後交換。咱們用變量 i 和變量 j 指向序列的最左邊和最右邊。剛開始時最左邊 i=0 指向 6，最右邊 j=9 指向 8

（2）如今設置的基準數是最左邊的數，因此序列先右往左移動（j--），當找到一個 <6 的數（5）就停下來。接着序列從左往右移動（i++），直到找到一個 >6 的數又停下來（7）；

（3）二者交換，結果：6 1 2 5 9 3 4 7 10 8；

 

（4）j 的位置繼續向左移動（友情提示：每次都必須先從 j 的位置出發），發現 4 知足要求，接着 i++ 發現 9 知足要求，交換後的結果：6 1 2 5 4 3 9 7 10 8；

（5）目前 j 指向的值爲 9，i 指向的值爲 4，j-- 發現 3 符合要求，接着 i++ 發現 i=j，說明這一輪移動結束啦。如今將基準數 6 和 3 進行交換，結果：3 1 2 5 4 6 9 7 10 8；如今 6 左邊的數都是 <6 的，而右邊的數都是 >6 的，但遊戲還沒結束

（6）咱們將 6 左邊的數拿出來先：3 1 2 5 4，此次以 3 爲基準數進行調整，使得 3 左邊的數 <3，右邊的數 >3，根據以前的模擬，此次的結果：2 1 3 5 4

（7）再將 2 1 摳出來從新整理，獲得的結果： 1 2

（8）剩下右邊的序列：9 7 10 8 也是這樣來搞，最終的結果： 1 2 3 4 5 6 7 8 9 10 （具體看下圖）

快速排序的每一輪處理其實就是將這一輪的基準數歸位，當全部的基準數歸位，排序就結束啦

 

java代碼實現：

 

/**
     * 查找出中軸（默認是最低位low）的在numbers數組排序後所在位置
     * 
     * @param numbers
     *            帶查找數組
     * @param low
     *            開始位置
     * @param high
     *            結束位置
     * @return 中軸所在位置
     */
    public static int getMiddle(int[] numbers, int low, int high) {
        int temp = numbers[low]; // 數組的第一個做爲中軸
        while (low < high) {
            while (low < high && numbers[high] > temp) {
                high--;
            }
            numbers[low] = numbers[high];// 比中軸小的記錄移到低端
            while (low < high && numbers[low] < temp) {
                low++;
            }
            numbers[high] = numbers[low]; // 比中軸大的記錄移到高端
        }
        numbers[low] = temp; // 中軸記錄到尾
        return low; // 返回中軸的位置
    }

    /**
     * 
     * @param numbers
     *            帶排序數組
     * @param low
     *            開始位置
     * @param high
     *            結束位置
     */
    public static void quickSort(int[] numbers, int low, int high) {
        if (low < high){
            int middle = getMiddle(numbers, low, high); // 將numbers數組進行一分爲二
            quickSort(numbers, low, middle - 1); // 對低字段表進行遞歸排序
            quickSort(numbers, middle + 1, high); // 對高字段表進行遞歸排序
        }
    }

    /**
     * 快速排序
     * 
     * @param numbers
     *            帶排序數組
     */
    public static void quick(int[] numbers) {
        // 查看數組是否爲空
        if (numbers.length > 0) {
            quickSort(numbers, 0, numbers.length - 1);
        }
    }

    /**
     * 打印
     * @param numbers
     */
    public static void printArr(int[] numbers) {
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + ",");
        }
        System.out.println("");
    }

    
    
    public static void main(String[] args) {
        int[] numbers = { 10, 20, 15, 0, 6, 7, 2, 1, -5, 55 };
        System.out.print("排序前：");
        printArr(numbers);

        quick(numbers);
        System.out.print("快速排序後：");
        printArr(numbers);
    }

 

參考文章：

 http://www.cnblogs.com/liqingwen/p/4994261.html

 

http://www.cnblogs.com/0201zcr/p/4763806.html