冒泡，插入，快排，归并。（仅作记录，每个写的都有很大瑕疵问题，不要参考）

public int[] bubbleSort(int[] data) {
    for (int i = 0; i < data.length; i++) {
        for (int j = 0; j < data.length - i - 1; j++) {
            if (data[j] > data[j + 1]) {
                int temp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = temp;
            }
        }
    }
    return data;

}

public int[] insertSort(int[] data) {
    for (int i = 1; i < data.length; i++) {
        int j = i - 1;
        while (j >= 0 && data[j] > data[j + 1]) {
            int tmp = data[j];
            data[j] = data[j + 1];
            data[j + 1] = tmp;
            j--;
        }
    }
    return data;
}

public int[] mergeSort(int[] data) {
    if (data.length==0 ||data.length==1) {
        return data;
    }
    int mid = (data.length-1) / 2;

    int[] lef = mergeSort(Arrays.copyOfRange( data ,0, mid+1));
    int[] rig = mergeSort(Arrays.copyOfRange( data ,mid+1, data.length));
    return mergeTwo(lef, rig);
}

public int[] mergeTwo(int[] data1, int[] data2) {
    int[] res = new int[data1.length + data2.length];
    int resindex = 0;
    int index1 = 0;
    int index2 = 0;
    while (index1 <= data1.length - 1 && index2 <= data2.length - 1) {
        if (data1[index1] <= data2[index2]) {
            res[resindex] = data1[index1];
            resindex++;
            index1++;
        } else if (data1[index1] > data2[index2]) {
            res[resindex] = data2[index2];
            resindex++;
            index2++;
        }
    }
    while (index1 <= data1.length - 1) {
        res[resindex] = data1[index1];
        resindex++;
        index1++;
    }
    while (index2 <= data2.length - 1) {
        res[resindex] = data2[index2];
        resindex++;
        index2++;
    }
    return res;
}



/**
 * 快排核心算法，递归实现
 * @param array
 * @param left
 * @param right
 */
public  void fastsort(int[] array, int left, int right) {
    if(left > right) {
        return;
    }
    // base中存放基准数
    int base = array[left];
    int i = left, j = right;
    while(i != j) {
        // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
        while(array[j] >= base && i < j) {
            j--;
        }

        // 再从左往右边找，直到找到比base值大的数
        while(array[i] <= base && i < j) {
            i++;
        }

        // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
        if(i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    // 将基准数放到中间的位置（基准数归位）
    array[left] = array[i];
    array[i] = base;

    // 递归，继续向基准的左右两边执行和上面同样的操作
    // i的索引处为上面已确定好的基准值的位置，无需再处理
    fastsort(array, left, i - 1);
    fastsort(array, i + 1, right);
}