【左程云算法】时间复杂度（Olog（N^2））和冒泡排序 选择排序

目录

01 时间复杂度分析

02 选择排序及时间复杂度分析

 2.1 算法步骤

2.2 代码实现 

 03 冒泡排序算法和时间复杂度分析

3.1 算法步骤

3.2 代码实现

 3.3 冒泡排序算法的优化

04 异或^的理解

4.1 寻找数组中出现的单数

4.1.1 题目：一组数只有一个数出现奇数次，其他出现偶数次，找出这个出现奇数次的数 

 4.1.2 一组数只有两个数出现一次，其他出现两次，找出这两个数：

05 插入排序

5.1 算法步骤

5.2 代码示例 

5.2.1 示例1

 5.2.2 示例2

5.3 时间复杂度分析

06 对数器

07 二分法详解及扩展（O(Log)）

7.1 在一个有序数组中，找一个数是否存在，复杂度少于（O(N))

7.2 在一个有序数组中找到 >= 某个数最左侧位置

7.3 局部最小值问题

---

01 时间复杂度分析

常数时间的操作：一个操作如果和数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。我的理解是这种操作最终的执行就是执行汇编命令，而汇编命令执行花费的时间都是有限的机器时钟时间，可以简单理解为执行一个相加指令，所以常数操作花费的时间是确定有限的，和数量级没关系。

时间复杂度为一个算法流程中，常数操作数量的指标，常用O（读作 big O）来表示。具体来说，在常数操作数量的表达式中，只要有高阶项，不要低阶项，也不要高阶项的系数，剩下的部分如果记为f(N),那么时间复杂度为O(f(N))。

评价一个算法流程的好坏，先看时间复杂度的指标，然后再分析不同数据样本下的实际运行时间，也就是常数项时间。

• 举例

public class Test {
    public void proffessor1(){
        int a = 0;
        for (int i = 0; i < 1000; i++){
            a = 3 + 4;
            a = 3 - 5;
            a = 3 * 77;
        }
    }

    public void proffessor2(){
        int a = 0;
        for (int i = 0; i < 1000; i++){
            a = 3 ^ 4;
            a = 3 & 5;
            a = 3 | 77;
        }
    }
}

两个代码时间复杂度相同均为O(N),比较时间复杂度需要比较常数项操作需要时间，即实际运行时间

02 选择排序及时间复杂度分析

第一次从0 .................n-1中选择出最小（大）值放在0
第二次从 1 .................n-1中选择出最小（大）值放在1
第三次从 2 .................n-1中选择出最小（大）值放在2
直到选择完： 等差数列（时间复杂度O（N^2）, 额外空间复杂度O（1）） 

 2.1 算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

2.2 代码实现 

import java.util.Arrays;

public class SelectionSort {
    public static void SelectionSort(int[] arr){
        // 首先判断输入合法性
        if(arr == null || arr.length < 2){
            System.out.println("不需要排序");
            return;
        }
        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;
                }
            }
            swap(arr, i, minIndex);
        }

    }

   public static void swap(int[] arr, int i, int j){
        if(i != j){
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
    }

    public static void main(String[] args){
        int[] arr = new int[]{3,5,2,-2,7,9,-10};
        SelectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

 03 冒泡排序算法和时间复杂度分析

第一次冒：0 ............. n-1
第二次冒：0 ....... n-2
第三次冒：0 ... n-3
直到冒完，每次比较大的数放在后面（时间复杂度O(N^2), 额外复杂度 O(1)）

3.1 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

3.2 代码实现

import java.util.Arrays;

public class BubbleSort {
    public static void BubbleSort(int[] arr){
        if(arr.length < 2 || arr == null){
            System.out.println("无需排序");
            return;
        }

        // for(int i = 0; i < arr.lenth - 1; i++){  // 把最大的数排在最后一位
            // for(int j = 0; j < arr.lenth - 1 - i; j++){  // 第二大的数排在倒数第二位

        for(int e = arr.length - 1; e >= 0; e--){
            for(int i = 0 ; i < e; i ++){
                if(arr[i] > arr[i + 1]){
                    swap(arr, i, i +1);
                }
            }
        }
    }

    public static void swap(int[] arr, int i, int j){
        if(i != j){
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
    }

    public static void main(String[] args){
        int[] arr = new int[]{3,5,2,-2,7,9,-10};
       BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

 3.3 冒泡排序算法的优化

如果