冒泡

    public static void bubbleSort(int arr[], int length) {
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp;
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

选择

    public static void selectionSort(int arr[], int length) {
        int index, temp;
        for (int i = 0; i < length; i++) {
            index = i;
            for (int j = i + 1; j < length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            if (index != i) {
                temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
        }
    }

插入排序

    void InsertSort(int arr[], int length) {
        for (int i = 1; i < length; i++) {
            int j;
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                    arr[j + 1] = arr[j];
                }
                arr[j + 1] = temp;
            }
        }
    }

快速排序

    // 快速排序
    void QuickSort(int arr[], int start, int end) {
        if (start >= end) {
            return;
        }
        int i = start;
        int j = end;
        // 基准数
        int baseval = arr[start];
        while (i < j) {
            // 从右向左找比基准数小的数
            while (i < j && arr[j] >= baseval) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            // 从左向右找比基准数大的数
            while (i < j && arr[i] < baseval) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        // 把基准数放到i的位置
        arr[i] = baseval;
        // 递归
        QuickSort(arr, start, i - 1);
        QuickSort(arr, i + 1, end);
    }

归并排序

    /**
     * 归并排序
     *
     * @param array
     */
    public static void MergeSort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        MergeSortRecursive(array, left, right);
    }
    /**
     * 归并排序的递归方法
     *
     * @param array
     * @param left
     * @param right
     */
    public static void MergeSortRecursive(int[] array, int left, int right) {
        if (left >= right) {
            return;  //递归的停止判断，没有这个判断会报StackOverflowError
        }
        int mid = (left + right) / 2;
        MergeSortRecursive(array, left, mid);
        MergeSortRecursive(array, mid + 1, right);
        Merge(array, left, mid, right);
    }
    /**
     * 归并排序中合并方法
     *
     * @param array
     * @param left
     * @param mid
     * @param right
     */
    public static void Merge(int[] array, int left, int mid, int right) {
        int r_left = mid + 1; //需要合并数组中右边数组第一个数索引
        int[] tempArray = new int[array.length];//一个临时数组，用于合并时暂时存储
        int newIndex = left;   //临时数组索引
        int tempLeft = left;   //合并完了以后，用于复制数组的索引
        while (left <= mid && r_left <= right) {   //将部分的数放入到临时数组中
            if (array[left] < array[r_left]) {
                tempArray[newIndex++] = array[left++];
            } else {
                tempArray[newIndex++] = array[r_left++];
            }
        }
        while (left <= mid) {
            tempArray[newIndex++] = array[left++];  //将左边还剩余的数放入临时数组(若需要合并的左边还剩余数)
        }
        while (r_left <= right) {
            tempArray[newIndex++] = array[r_left++];//将右边还剩余的数放入临时数组(若需要和并的右边还剩余数)
        }
        while (tempLeft <= right) {
            array[tempLeft] = tempArray[tempLeft++];  //将临时数组复制到array
        }
    }

希尔排序

    void ShellSort(int arr[], int length) {
        int increasement = length;
        int i, j, k;
        do {
            // 确定分组的增量
            increasement = increasement / 3 + 1;
            for (i = 0; i < increasement; i++) {
                for (j = i + increasement; j < length; j += increasement) {
                    if (arr[j] < arr[j - increasement]) {
                        int temp = arr[j];
                        for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement) {
                            arr[k + increasement] = arr[k];
                        }
                        arr[k + increasement] = temp;
                    }
                }
            }
        } while (increasement > 1);
    }