這裡主要介紹一下氣泡排序和選擇排序的簡單使用，給初學者一些參考，可能和別人的有點不一樣，這主要是我自己的一些思路，和別人是有一些出入的。

      直接上程式碼，註釋在程式碼中：

package com.Jevin.chapter01;

/**
 * 這裡介紹一下冒泡和選擇排序：
 */
public class Sort {
    public static void main(String[] args) {
        int[] arr={12,1,23,6,78,36,17,12};
        //int[] array=test01(arr);
        int[] array=test02(arr);
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
    }

    //氣泡排序：從小到大
    public static int[] test01(int[] arr){
        /**
         * 外層迴圈表示要排序的輪數，每一輪選出一個最大數，最後只剩一個數不許比較，所以是i<=arr.length-1
         * 那麼這裡為什麼不寫成i<arr.length呢，寫成i<=arr.length-1更能體現它的數學思想，便於思考；
         */
        for(int i=1;i<=arr.length-1;i++){
            /**
             * 內層迴圈表示每一輪要比較的次數,j這裡承擔了兩個角色，第一，作為數的索引；第二，每一輪要比較的次數；
             * 每一輪比較的次數應該是arr.length-i(即為，每一輪迴圈選出了一個最大數，下一輪這個最大數不需要再參與比較，
             * 所以要減i);但是下面if(){}語句arr[j+1],j多取到了索引後一位，所以需要再減去1；
             */
            for(int j=0;j<=arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }



    //選擇排序：從小到大
    public static int[] test02(int[] arr){
        /**
         * 外層迴圈表示要比較的輪數，同氣泡排序；
         */
        for(int i=1;i<=arr.length-1;i++){
            /**
             * 這裡設定了一個索引index,它表示一個指標，儲存在此索引中的數預設是從小到大的；
             */
            int index=i-1;
            /**
             * 內層迴圈表示每一輪要比較的次數，假設index中儲存的是最小數，那麼將index後的每一個數
             * 與之比較，如若小於它，則交換索引，這樣保證index中始終儲存的是相對最小數；
             */
            for(int j=i;j<=arr.length-1;j++){
                if(arr[index]>arr[j]){
                    index=j;
                }
            }
            //將儲存在index索引中的最小數重新放到它原來的位置上；
            int temp=arr[i-1];
            arr[i-1]=arr[index];
            arr[index]=temp;
        }
        return arr;
    }
}
 

     然後，是這兩種排序的簡單應用：

package com.Jevin.chapter01;

import java.util.Arrays;

/**
 * 這裡要解決的問題是：
 *                     假設一組N個數，要確定其中的第k個最大數：
 */
public class Cite {
    public static void main(String[] args){

        int[] arr=new int[]{9,4,14,25,98,47};

        //test01()使用氣泡排序法求出第三個最大數：
        /*int value01=test01(arr,3);
        System.out.println(value01);*/ //k=3，即第三個最大數，為25

        //test02()使用選擇排序法求出第三個最大數：
        /*int value02=test02(arr,3);
        System.out.println(value02);*/

        //test03()思路二：
        int value03=test03(arr,3);
        System.out.println(value03);

        /**
         * 可以看到思路二的迴圈次數明顯少於思路一的冒泡和選擇排序，因此思路二在處理大量資料的效率上要優於思路一；
         */
    }

    /**
     * 思路一：將這N個數按照冒泡或者選擇排序法從大到小排列，找到第k個數，即為所得；
     */
    //方法一：這裡使用氣泡排序法：
    public static int test01(int[] arr,int k){
        for(int i=1;i<=arr.length-1;i++){
            for(int j=0;j<=arr.length-i-1;j++){
                if(arr[j]<arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr[k-1];
    }

    //方法二：這裡使用選擇排序法：
    public static int test02(int[] arr,int k){
        for(int i=1;i<=arr.length-1;i++){
            int index=i-1;
            for(int j=i;j<=arr.length-1;j++){
                if(arr[index]<arr[j]){
                    index=j;
                }
            }
            int temp=arr[i-1];
            arr[i-1]=arr[index];
            arr[index]=temp;
        }
        return arr[k-1];
    }


    /**
     *思路二：1.將此陣列arr中的前k個元素取出來組成一個新的陣列brr，並從大到小排序;
     *        2.剩下的元素逐個錄入，如果小於第k個元素，則忽略；如果大於，則將其放入到陣列brr中的相應的位置，
     *        此時陣列brr會多出一個元素k+1，舍掉，以此迴圈往復到最後一個元素即可得到最後的brr，且brr第k個元素即為arr的第k個最大者；
     */

    public static int test03(int[] arr,int k){
        int[] brr=Arrays.copyOfRange(arr,0,k);
        brr=arraySort(brr);
        //for(){}迴圈表示陣列arr被擷取後的元素逐個錄入：
        for(int i=brr.length;i<arr.length;i++){
            if(brr[brr.length-1]>arr[i]){
                //如果arr剩下的元素都小於crr的第k個元素，則crr中的最後一個元素即為arr中的第k個最大者：
                continue;   //結束當前迴圈，進行下一次迴圈；注意這裡千萬不要用break或者是return,要不然結束直接跳出迴圈體了；
            }else{
                //只要arr剩下的元素出現一個比crr中的元素中的大者，則crr加上這個元素重新排序，並踢出最小的那個：
                brr=Arrays.copyOf(brr,brr.length+1);
                brr[brr.length-1]=arr[i];
                brr=arraySort(brr);
                brr=Arrays.copyOfRange(brr,0,brr.length-1);
                continue;
            }
        }
        return brr[brr.length-1];
    }

    //這裡進行陣列排序，方便其他方法的呼叫：
    public static int[] arraySort(int[] arr){
        for(int i=1;i<=arr.length-1;i++){
            for(int j=0;j<=arr.length-i-1;j++){
                if(arr[j]<arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }
}