一、3种时间复杂度为O(n²)的排序算法

冒泡排序 、 插入排序 、选择排序------简述

三者时间复杂度均为O(n²)，且都是基于比较的排序。

1.冒泡排序

• 核心思想：
  • 冒泡排序每次只会比较相邻的两个元素，如果不满足大小要求，就互换位置。
  • 每一轮冒泡排序都会将至少一个元素排到它应该在的位置，因此理论上进行至多n-1轮（n为数据总量）冒泡，就能排序完毕。
  • 实际上可以设定一个flag标志位来监测每轮冒泡时是否发生了数据交换从而提前退出冒泡排序。
• 注意：
  • 冒泡排序是原地、稳定的排序算法。
  • 时间复杂度：O(n²)。

　　

public static void bubbleSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        for(int i = 0;i < arr.length - 1;i++){
            boolean flag = false;//默认没有数据交换
            for(int j = 0;j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
            if(!flag)break;
        }
    }

 

2.插入排序

• 核心思想
  • 插入排序分为已排序区间和未排序区间
  • 每次取未排序区间中的元素插入到已排序区间中合适的位置
• 注意：
  • 插入排序是原地、稳定的排序算法
  • 时间复杂度：O(n²)

    public static void insertionSort(int[] arr){

        if(arr == null || arr.length < 2) return;

        //初始已排序区间只有一个元素，未排序区间有n-1个元素
        //我们是在未排序区间中取数，即从左到右遍历，因此i的初始值为1而不是0
        for(int i = 1;i < arr.length;i++){
            //对于每一轮排序，开始从右往左遍历已排序区间，同时进行数据交换
            //直到满足大小要求
            for(int j = i - 1;j >= 0 && arr[j] > arr[j + 1];j--){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

 

3.选择排序

• 核心思想：
  • 同样分为已排序区间和未排序区间
  • 和插入排序不同的是，比较发生在未排序区间中
  • 从未排序区间中选择最小的元素放到已排序区间的末尾
• 注意：
  • 选择排序是原地、不稳定的排序算法
  • 时间复杂度：O(n²)

   public static void selectionSort(int[] arr){

        if(arr == null || arr.length < 2) return;
        
        //初始都是未排序区间
        for(int i = 0;i < arr.length - 1;i++){
            int mix = i;
            for(int j = i+1;j < arr.length;j++){
                mix = arr[j] < arr[mix] ? j:mix;
            }
            int temp = arr[mix];
            arr[mix] = arr[i];
            arr[i] = temp;
        }

    }