冒泡排序：

public class Bubble {
public int[] sort(int[] array) {
    int temp = 0;
    // 外层循环，它决定一共走几趟 //-1为了防止溢出
    for (int i = 0; i < array.length - 1; i++) {
        int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环
        //内层循环，它决定每趟走一次
        for (int j = 0; j < array.length - i - 1; j++) {
            //如果后一个大于前一个,则换位
            if (array[j + 1] > array[j]) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag = 1;
            }
        }
        if(flag == 0){
                break;
        }
    }
    return array;
}
}

选择排序：

public class SelectSort {
    public int[] sort(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            // 认为目前的数就是最小的, 记录最小数的下标
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {
                    // 修改最小值的下标
                    minIndex = j;
                }
            }
            // 当退出for就找到这次的最小值,就需要交换位置了
            if (i != minIndex) {
                //交换当前值和找到的最小值的位置
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    return arr;
    }
}

插入排序：

public class InsertSort {
    private int[] sort(int[]arr){
        //如果传入的数组为空或者只有一个值,就直接返回
        if(arr == null || arr.length < 2){
            return arr;
        }
        //不为空则进循环判断
        //外层循环控制总数量
        for(int i=1;i<arr.length;i++){
            //内层循环依次减少并提出结果
            for(int j=i;j>0;j--){
                //如果当前数字小于前一个,则交换,否则不变
                if(arr[j]<arr[j-1]){
                    int temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }else{
                    break;
                }
            }
        }
    return arr;
}