简单排序之冒泡排序、选择排序和插入排序

冒泡排序

排序原理

1. 冒泡排序简而言之是将两个连续相邻的数字进行比较，不断把大的数字往后放
2. 放在后面的的数字即为排序完毕的较大的数字
3. 时间复杂度为O(n^2)
   

public class Bubble {
    
    //用来实现排序
    public static void sort(Comparable[] arr){
        int len = arr.length;
        //这里用来每次排序的数字减少一个
        for (int i = len ; i > 0 ; i--){
            //用来排序前面的数字
            for (int j = 0 ; j < i-1 ; j++){
                if (greater(arr[j],arr[j+1])){
                    change(arr,j,j+1);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    //用来实现num1和num2的数字大小比较
    public static boolean greater(Comparable num1 , Comparable num2){
        //如果返回true，则表明num1大于num2
        return num1.compareTo(num2)>0;
    }

    //用来实现数组中i和j位置数据的交换
    public static void change(Comparable[] arr, int i , int j){
        Comparable temp = arr[i];
        arr[i] =  arr[j];
        arr[j] = temp;
    }
}

选择排序

排序原理

1. 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
2. 交换第一个索引处和最小值所在的索引处的值
3. 时间复杂度为O(n^2)

//实现选择排序
public class Selection {
    //实现排序
    public static void sort(Comparable[] arr) {
        int len = arr.length;
        for (int i = 0 ; i < len; i++ ){
            //用来记录当前的比较值
            int index = i ;
            for ( int j = i+1 ; j < len; j++){
                //如果index比当前值更大（即当前值更小），则把当前值给index存储
                if (greater(arr[index],arr[j])){
                    index = j;
                }
            }
            //交换当前值为最小值
            change(arr,i,index);
        }
        System.out.println(Arrays.toString(arr));
    }

    //用来实现num1和num2的数字大小比较
    public static boolean greater(Comparable num1 , Comparable num2){
        //如果返回true，则表明num1大于num2
        return num1.compareTo(num2)>0;
    }

    //用来实现数组中i和j位置数据的交换
    public static void change(Comparable[] arr, int i , int j){
        Comparable temp = arr[i];
        arr[i] =  arr[j];
        arr[j] = temp;
    }
}

插入排序

排序原理

1. 把所有的元素分为两组，已经排序的和未排序的
2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入
3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，如果数字比待插入数字更大，则交换位置，直到找到一个元素小于等于待插入元素，则停止，不交换位置，排序结束
4. 时间复杂度为O(n^2)

//实现插入排序
public class Insertion {

    //实现排序
    public static void sort(Comparable[] arr) {
        int len = arr.length;
        for (int i = 1 ;i < len ;i++){
            // 注意越界
            // 因为我们arr[j]只需要和他的上一个值比较即可
            // 所以当j=1的时候，我们已经和j=0的数据进行了比较
            for (int j = i ; j >0 ;j--){
                //如果前一个值比当前值更大，则交换位置
                //所以我们在移动的值一直都是arr[j]
                if (greater(arr[j-1],arr[j])){
                    change(arr,j-1,j);
                }else {
                    //找不到元素，则停止
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    //用来实现num1和num2的数字大小比较
    public static boolean greater(Comparable num1 , Comparable num2){
        //如果返回true，则表明num1大于num2
        return num1.compareTo(num2)>0;
    }

    //用来实现数组中i和j位置数据的交换
    public static void change(Comparable[] arr, int i , int j){
        Comparable temp = arr[i];
        arr[i] =  arr[j];
        arr[j] = temp;
    }
}

---

引用：
[1]. 黑马程序员排序算法
[2]. 冒泡排序算法图