总结所有的排序方式

一、插入排序

就是从左到右遍历，然后看看这个数是否比前面的数小，如果比前面的小就插入到这个数的前面。

public static void insertionSort(int[] arr) {
        if (arr != null && arr.length >= 2) {
            for(int i = 1; i < arr.length; ++i) {
                for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; --j) {
                    swap(arr, j, j + 1);
                }
            }
        }
}

二、冒泡排序

所谓的冒泡，就是小的数不断的跳到左边。这里注意，每一次循环，最小的值都会到最后一位。

    public static void sort(int[] arr) {
        if (arr != null && arr.length > 2) {
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = arr.length - 1; j >= i + 1; j--) {
                    if (arr[j] < arr[j - 1]) {
                        swap(arr, j, j - 1);
                    }
                }
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

 三、归并排序

归并排序稍微比较复杂，感觉怎么讲都有点讲不太明白，主要是merge的代码较为复杂，其他的就是和递归结合，还是得看代码，注意边际条件。

　　public static void mergeSort(int[] arr) {
        if (arr != null && arr.length > 2) {
            mergeSort(arr, 0, arr.length - 1);
        }
    }
    public static void mergeSort(int[] arr, int L, int R) {
        if (L != R) {
            int mid = (L + R) / 2;
            mergeSort(arr, L, mid);
            mergeSort(arr, mid + 1, R);
            merge(arr, L, mid, R);
        }
    }
    public static void merge(int[] arr, int start , int mid, int end) {
        int[] helpArr = new int[end - start + 1];
        int i = start;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= end) {
            helpArr[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }
        while (i <= mid) {
            helpArr[k++] = arr[i++];
        }
        while (j <= end) {
            helpArr[k++] = arr[j++];
        }
        for (int index = 0; index <= end - start; index++) {
            arr[start + index] = helpArr[index];
            System.out.println(helpArr[index]);
        }
    }