1.選擇排序

基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換；然後在剩下的數當中再找最小的與第二個位置的數交換，如此迴圈到倒數第二個數和最後一個數比較為止。

程式碼實現

public class SelectSort {

    /**
     * 選擇排序演算法
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置  
     * 再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾。 
     * 以此類推，直到所有元素均排序完畢。 
     * @param args
     */
    public static void main
 
(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        selectSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }

    }
    public static void selectSort(int num[]){
        int size=num.length;
        int
 
 temp=0;

        for(int i=0;i<size;i++){
            int k=i;
            for(int j=size-1;j>i;j--){
                if(num[j]<num[k]){//找到比第i個最小的元素
                    k=j;
                }
            }
            //將最小的元素與第i個交換
            temp=num[k];
            num[k]=num[i];
            num[i]=temp;
        }

    }

}
 

2.快速排序

• 基本思想：假設我們現在對“6 1 2 7 9 3 4 5 10 8”這個10個數進行排序。首先在這個序列中隨便找一個數作為基準數（不要被這個名詞嚇到了，就是一個用來參照的數，待會你就知道它用來做啥的了）。為了方便，就讓第一個數6作為基準數吧。接下來，需要將這個序列中所有比基準數大的數放在6的右邊，比基準數小的數放在6的左邊，類似下面這種排列：
  3 1 2 5 4 6 9 7 10 8
  在初始狀態下，數字6在序列的第1位。我們的目標是將6挪到序列中間的某個位置，假設這個位置是k。現在就需要尋找這個k，並且以第k位為分界點，左邊的數都小於等於6，右邊的數都大於等於6。

public class QuickSort {

    /**
     * 快速排序演算法
     * 開始以0位置為基準數
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        quickSort(a,0,a.length-1);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }

    }
    public static void quickSort(int num[],int left,int right){
        int i,j,t,temp;
        if(right<left) return;
        temp=num[left];
        i=left;
        j=right;
        while(i!=j){
            //右邊一定要先走
            while(num[j]>=temp&j>i)
                j--;
            //左邊開始向右走
            while(num[i]<=temp&j>i)
                i++;
            if(i<j){
                t=num[j];
                num[j]=num[i];
                num[i]=t;
            }
        }
        num[left]=num[i];
        num[i]=temp;
        quickSort(num, left, i-1);
        quickSort(num, i+1, right);     
    }

}

3.插入排序

基本思想：每步將一個待排序的記錄，按其順序碼大小插入到前面已經排序的字序列的合適位置（從後向前找到合適位置後），直到全部插入排序完為止。
**時間複雜度：**O（n^2）.

public class InsertSort {

    /**
     * 插入排序演算法
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        insertSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
    public static void insertSort(int num[]){
        int size=num.length;
        int temp=0;
        int j=0;
        for(int i=0;i<size;i++){
            temp=num[i];
            for(j=i;j>0&&temp<num[j-1];j--){
                num[j]=num[j-1];//後移一位
            }
            num[j]=temp;

        }
    }

}

4.希爾排序

基本思想：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。
**時間複雜度：**O（n^2）.　

public class ShellSort {
    /**希爾排序的原理:根據需求，如果你想要結果從大到小排列，它會首先將陣列進行分組，然後將較大值移到前面，較小值
     * 移到後面，最後將整個陣列進行插入排序，這樣比起一開始就用插入排序減少了資料交換和移動的次數，可以說希爾排序是加強
     * 版的插入排序
     * 拿陣列5, 2, 8, 9, 1, 3，4來說，陣列長度為7，當increment為3時，陣列分為兩個序列
     * 5，2，8和9，1，3，4，第一次排序，9和5比較，1和2比較，3和8比較，4和比其下標值小increment的陣列值相比較
     * 此例子是按照從大到小排列，所以大的會排在前面，第一次排序後陣列為9, 2, 8, 5, 1, 3，4
     * 第一次後increment的值變為3/2=1,此時對陣列進行插入排序，
     *實現陣列從大到小排
     */
        public static void main(String arg[]){
            int a[]={23,12,45,10,32};
            shellSort(a);
            for (int i=0 ;i<a.length;i++) {
                System.out.print(a[i]+" ");
            }
        }
        public static void shellSort(int[] data) 
        {
            int j = 0;
            int temp = 0;
            //每次將步長縮短為原來的一半
            for (int increment = data.length / 2; increment > 0; increment /= 2)
            {
            for (int i = increment; i < data.length; i++) 
            {
                temp = data[i];
                for (j = i; j >= increment; j -= increment) 
                {
                if(temp > data[j - increment])//如想從小到大排只需修改這裡
                {   
                    data[j] = data[j - increment];
                }
                else
                {
                    break;
                }

                } 
                data[j] = temp;
            }       
          }
        }
}

5.氣泡排序

基本思想：氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

public class FloatBallSort {

    /**
     *從小到大順序排序
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[]={23,12,45,10,32};
        floatBallSort(a);
        for (int i=0 ;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
    public static void floatBallSort(int num[]){
        int size=num.length;
        int temp=0;

        for(int i=0;i<size;i++){
            for(int j=size-1;j>i;j--){
                if(num[j]<num[i]){
                    temp=num[i];
                    num[i]=num[j];
                    num[j]=temp;
                }
            }
        }
    }
}