常见排序算法中的冒泡排序的时间复杂度是(常见排序算法复杂度)

1.冒泡算法

首先遍历整个数组，从前往后依次判断相邻两个元素数值大小，若后一个元素小于前一个元素，则将二者调换位置，那么遍历之后数组最后一个元素将是整个数组中的最大值。然后再遍历前n-1个元素找到最大值放在最右端，再进入下一轮如此往复直至剩下最后一个元素，结束，该过程总共要进行n -1轮遍历。

public void bubbleSort(int[] arr){
    if (arr == null || arr.length < 2){
            return;
        }
    else{
        for(int i = 0; i < arr.length - 1; i++){
            for(int j = 0; j < arr.length - 1 - i; j++)
                if(arr[j] > arr[j + 1]){
                    swap(arr, j, j + 1);
                }
            }
        } 
    }
}
public void swap(int[] arr, int i, int j){
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

2.选择算法

先遍历整个数组，找出数组中值最小的元素，放在最前面，此过程先假设最小索引为0，再和后面的元素依次判断，不停更新索引。然后依次找出后面元素的最小值放在索引为1，2，3....n-1的位置。

public void chooseSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        else {
            for (int i = 0; i < arr.length - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < arr.length; j++) {
                    minIndex = arr[minIndex] < arr[j] ? minIndex : j;
                }
                swap(arr, i, minIndex);
            }
        }
    }
    public void swap(int[] arr, int i, int j){
        int temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

3.插值算法

插值算法从数组的第二个元素开始，判断和前面元素关系，调整顺序，保证前两个元素有序，然后再从第三个元素往前看寻找合适的位置插入，保证前三个元素有序，如此往复，最后使得所有元素保证有序。

public void insertSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        } else {
            for (int i = 1; i < arr.length; i++) {
                for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                    swap(arr, j - 1, j);
                }
            }
        }
    }

    public void swap(int[] arr, int i, int j) {
        int temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }