冒泡排序

时间复杂度

O(n^2)

• 以数组为例：[]

• 比较的范围：{0~n-1},n--

• 比较的对象：相邻两个数

gif演示：

image

代码实现

pulic void static main(String[] args){
    int[] arry = {6,3,5,7,0,4,1,2}
    //外层控制比较范围
    //内层控制比较的对象
    for(int i = arry.length-1; i > 0;i--){
        for(int j = 0; j <=i;j++){
            if(arry[i]>arry[i+1]){
                int temp =arry[i];
                arry[i] = arry[i+1];
                arry[i+1] = temp;
            }
        }
    }
}

选择排序

时间复杂度

O(n^2)

• 以数组为例：[]

• 比较的范围：{i-n-1},i++

• 比较的对象：该范围内的最值

 public static void main(String[] args) {
        int[] array = {23,1,4,9,2,45,11};
        //描述：在一定范围内选择最小的放到这个范围的最前面
        for (int i = 0;i < array.length;i++){
            int min = array[i];
            int target = i;
            for (int j =i;j<array.length;j++){
                if(min > array[j]){
                   min = array[j];
                   target = j;
                }
            }
            //交换
            int temp = array[i];
            array[i] = min;
            array[target] = temp;
        }
        //输出测试
        for (int a:array){
            System.out.println(a);
        }
    }

插入排序

时间复杂度

O(n^2)

• 以数组为例：[]

• 比较的范围：每个位置和它之前的数比较

• 比较的对象：该位置和该位置之前的数

代码实现：

 public static void main(String[] args) {
        int[] array = {23,1,4,9,2,45,11};
        //外层控制靶子
        //内层控制比较的范围
        for (int i = 1;i < array.length;i++){
            int target = array[i];
            int targetIndex = i;
            for (int j = i;j>=0;j--){
                if (target < array[j]){
                    //交换
                    int temp = target;
                    array[targetIndex] = array[j];
                    array[j] = temp;
                    targetIndex = j;
                }
            }
        }
      //测试输出
        for (int a:array){
            System.out.println(a);
        }
    }

前面的三种排序算法都是时间复杂度n2的（O(n^2)）的