很早以前的程式碼了，今天發在這裡備份一下，也供有需要的朋友參考。

1. 排序中的數值交換

/**
     * 交換陣列中的兩個值的位置
     * @param datas
* @param ind1
     * @param ind2
     */
    private static void swap(int[] datas, int ind1, int ind2){
        try{
            int temp = datas[ind1];
            datas[ind1] = datas[ind2];
            datas[ind2] = temp;
        }catch (Exception ex){
            System.out.println(ex.getMessage());
        }
    }
 

2. 氣泡排序

/**
     * 氣泡排序
     * @param datas
     * @return
     */
    public static void Bubble(int[] datas){
        int end = datas.length - 1;
        for(int i = 0; i < end;i++){
            boolean flag = true;
            for(int j = 0; j < end - i; j++){
                if(datas[j] > datas[j + 1]){
                    swap(datas, j , j + 1);
                    flag = false;
                }
            }

            if(flag) break;
        }
    }

3. 插入排序

/**
     * 插入排序
     * @param datas
     */
    public static void insert(int[] datas){
        for(int i = 1; i < datas.length; i++){
            for(int j = i; j > 0;j--){
                if(datas[j] < datas[j - 1]){
                    swap(datas, j, j - 1);
                }
            }
        }
    }
 

4. 歸併排序

// *************** 歸併排序 **************************//
    public static void sort(int[] datas, int left, int right, int[] temp){
        if(left < right){
            int mid = (left + right) >> 1;
            sort(datas, left, mid, temp);
            sort(datas, mid + 1, right, temp);
            merge(datas, left, mid, right, temp);
        }
    }


    public static void merge(int[] datas, int left, int mid, int right, int[] temp){
        int i = left;
        int j = mid + 1;
        int t = 0;
        while(i <= mid && j <= right){
            if(datas[i] < datas[j]){
                temp[t++] = datas[i++];
            }else {
                temp[t++] = datas[j++];
            }
        }

        while(i <= mid){
            // 左側剩餘資料
            temp[t++] = datas[i++];
        }

        while(j <= right){
            // 右側剩餘資料
            temp[t++] = datas[j++];
        }

        // 將臨時陣列中的資料拷貝到原陣列中
        t = 0;
        while(left <= right){
            datas[left++] = temp[t++];
        }
    }
    // *************************************************//

5. 快速排序

public static void fast(int[] datas, int left, int right){
        if(left >= right) return;
        if(datas.length < 10){
            insertPos(datas, left, right);
            return;
        }

        int l = left;
        int r =right;
        int val = datas[left];
        int mid = (left + right) >> 1;
        int ind = left;
        if((datas[left] - datas[mid]) * ( datas[right] - datas[mid]) < 0){
            ind = mid;
            val = datas[mid];
        }else if((datas[left] - datas[right]) * (datas[mid] - datas[right]) < 0){
            ind = right;
            val = datas[right];
        }

        if(left != ind) {
            swap(datas, left, ind);
        }

        while (l < r){
            // 右側開始找比val小的值
            while(datas[r] >= val && l < r){
                r--;
            }
            // 左側開始找比val大的值
            while(datas[l] <= val && l < r){
                l++;
            }
            // 交換位置
            if(l < r){
                swap(datas, l, r);
            }
        }

        swap(datas, left, l);
        fast(datas, left, l - 1);
        fast(datas, l + 1, right);
    }

/**
     * 插入排序, 對陣列指定資料段排序
     * @param datas
     */
    public static void insertPos(int[] datas, int left, int right){
        if(left < right){
            for(int i = left + 1; i < right; i++){
                for(int j = i; j > left;j--){
                    if(datas[j] < datas[j - 1]){
                        swap(datas, j, j - 1);
                    }
                }
            }
        }

    }