时间复杂度

注意一：学习数据结构的方法

1：多写代码

2：多画图

3：多调试 知道代码是按什么逻辑操作的

（代码多写几遍，5》3》2）

注意二：两个for循环并列的时间复杂度是m+n 或O（n）

public void func(int m ,int n){
        for (int i = 0; i < m; i++) {
            System.out.println(i);
        }

        for (int i = 0; i < n; i++) {
            System.out.println(i);
        }
    }

注意二：二分查找的时间复杂度计算

int binarySearch(int[] array, int value) {
    int begin = 0;
    int end = array.length - 1;
    while (begin <= end) {
      int mid = begin + ((end-begin) / 2);
      if (array[mid] < value)
        begin = mid + 1;
      else if (array[mid] > value)
        end = mid - 1;
      else
        return mid;
   }
    return -1;
}

注意三：递归的时间复杂度计算

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1) * N;
}

总结：递归时间复杂度的计算：递归的次数 * 每次递归之后执行语句的次数

注意四：计算斐波那契递归的时间复杂度？

// 计算斐波那契递归fibonacci的时间复杂度？
int fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

复杂度的计算要结合代码思想来计算的，不能管靠看一眼代码就给出复杂度

注意五：计算斐波那契额数列的空间复杂度

int fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

O（n）

注意七：计算冒泡排序的空间复杂度

// 计算bubbleSort的空间复杂度？
void bubbleSort(int[] array) {
  for (int end = array.length; end > 0; end--) {
    boolean sorted = true; //开辟一个变量
    for (int i = 1; i < end; i++) {
      if (array[i - 1] > array[i]) {// for循环里面没有开辟一个变量
        Swap(array, i - 1, i);
        sorted = false;
     }
   }
    if (sorted == true) {
      break;
   }
      
      O（1）

i 所占的临时空间 从for循环开始到结束，这段时间一直占1个空间，m 会开辟n次空间但是每次结束都会销毁空间，所以可以说m一直临时占用1个空间
所以空间复杂度是1+1 = 2 即O（1）。

// 计算bubbleSort的空间复杂度？
void bubbleSort(int[] array) {
    int[] temp = new int[array.length];    //重新开辟了一个数组
    
  for (int end = array.length; end > 0; end--) {
    boolean sorted = true; 
    for (int i = 1; i < end; i++) {
      if (array[i - 1] > array[i]) {
        Swap(array, i - 1, i);
        sorted = false;
     }
   }
    if (sorted == true) {
      break;
   }
      
      O（n）

注意 : 空间复杂度算的是变量的个数. 也可以说是 开辟的最深的空间

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度