1.直接排序

直接選擇排序(Straight Select Sorting) 也是一種簡單的排序方法，它的基本思想是：第一次從R[0]~R[n-1]中選取最小值，與R[0]交換，第二次從R[1]~R[n-1]中選取最小值，與R[1]交換，....，第i次從R[i-1]~R[n-1]中選取最小值，與R[i-1]交換，.....，第n-1次從R[n-2]~R[n-1]中選取最小值，與R[n-2]交換，總共通過n-1次，得到一個按排序碼從小到大排列的有序序列。

例如:給定n=8，陣列R中的8個元素的排序碼為(8,3,2,1,7,4,6,5),則直接選擇排序的過程如下所示： 初始狀態 [ 8 3 2 1 7 4 6 5 ] 8 -- 1 第一次 [ 1 3 2 8 7 4 6 5 ] 3 -- 2 第二次 [ 1 2 3 8 7 4 6 5 ] 3 -- 3 第三次 [ 1 2 3 8 7 4 6 5 ] 8 -- 4 第四次 [ 1 2 3 4 7 8 6 5 ] 7 -- 5 第五次 [ 1 2 3 4 5 8 6 7 ] 8 -- 6 第六次 [ 1 2 3 4 5 6 8 7 ] 8 -- 7 第七次 [ 1 2 3 4 5 6 7 8 ] 排序完成

/*
 

    選擇排序。
    以一個角標的元素和其他元素進行比較。
    在內迴圈第一次結束，最值出現的頭角標位置上。
    */
public static void selectSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=x+1; y<arr.length; y++)//為什麼y的初始化值是 x+1？            因為每一次比較，
                                            //都用x角標上的元素和下一個元素進            行比較。
 

            {
                if(arr[x]>arr[y])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
      }

2.氣泡排序

氣泡排序（Bubble Sort），是一種電腦科學領域的較簡單的排序演算法。 它重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重複地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。 這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名“氣泡排序”。 冒泡

排序演算法的原理如下：

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
3. 針對所有的元素重複以上的步驟，除了最後一個。
4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

例如:給定n=8，陣列R中的8個元素的排序碼為(8,3,2,1,7,4,6,5),則氣泡排序的過程如下所示： 初始狀態 [ 8 3 2 1 7 4 6 5 ] 第一次 [ 3 2 1 7 4 6 5 8 ] 第二次 [ 2 1 3 4 6 5 7 8 ] 第三次 [ 1 2 3 4 5 6 7 8 ] 排序完成

/*
    氣泡排序。
    比較方式：相鄰兩個元素進行比較。如果滿足條件就進行位置置換。
    原理：內迴圈結束一次，最值出現在尾角標位置。
    */
    public static void bubbleSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=0; y<arr.length-x-1; y++)//-x:讓每次參與比較的元減。
                                                //-1:避免角標越界。
            {
                if(arr[y]>arr[y+1])
                {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
}

3.折半查詢(二分法)

演算法思想

二分查詢也稱折半查詢（Binary Search），它是一種效率較高的查詢方法。但是，折半查詢要求線性表必須採用順序儲存結構，而且表中元素按關鍵字有序排列。 首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查詢關鍵字比較，如果兩者相等，則查詢成功；否則利用中間位置記錄將表分成前、後兩個子表，如果中間位置記錄的關鍵字大於查詢關鍵字，則進一步查詢前一子表，否則進一步查詢後一子表。重複以上過程，直到找到滿足條件的記錄，使查詢成功，或直到子表不存在為止，此時查詢不成功。

/*
    為了提高查詢效率，可使用折半查詢的方式，注意：這種查詢只對有序的陣列有效。
    這種方式也成為二分查詢法。
    */
    public static int halfSeach(int[] arr,int key)
    {
        int min,mid,max;
        min = 0;
        max = arr.length-1;
        mid = (max+min)/2;

        while(arr[mid]!=key)
        {
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            
            if(min>max)
                return -1;
    
            mid = (max+min)/2;
        }
        return mid;
    }

4.陣列翻轉

/*
    反轉其實就是頭角標和尾角標的元素進行位置的置換，
    然後在讓頭角標自增。尾角標自減。
    當頭角標<尾角標時，可以進行置換的動作。
    */
    public static void reverseArray(int[] arr)
    {
        for(int start=0,end=arr.length-1; start<end; start++,end--)
        {
            swap(arr,start,end);
        }
    }
    //對陣列的元素進行位置的置換。
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }