Java 数据结构第六课：时间复杂度和空间复杂度

**复杂度？**→粗略衡量算法好坏的刻度尺（工具）<指的是最坏情况下的时间复杂度>
两个维度： 快慢 ： 时间复杂度
使用空间情况 ： 空间复杂度
1.时间复杂度：算法的基本操作的执行次数为算法的时间复杂度
1>.前提：如果指定CPU的情况下，单位时间内运行的基本指令个数是固定的；算法计算的快慢和输入数据的规模是有关系的。
如果一个算法需要的指令比另一个算法需要的指令个数小，就可以退出算法A的运行时间
★常见的时间复杂度：O(1),O(log(n)),O(n),O(n*log(n)),O(n²)
2>.粗略计算算法的快慢
n:数据的规模
f(n):n的数据规模情况下，需要的大概指令个数
3>.引入大O渐进表示法
O(f(n)): ①只保留最高次项
②保留的最高次项系数化为1
☆算法的快慢分最好的情况(最后关注)、平均情况(其次关注)、最坏情况(最优先关注)
○最坏情况：任意输入规模的最大运行次数(上界)
○平均情况：任意输入规模的期望运行次数
○最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
例题：

Func1:
void Func1(int N){
    int count = 0;
    for (int i = 0; i < N ; i++) {
    for (int j = 0; j < N ; j++) {
    count++;                                               //N²
    }
    }
    for (int k = 0; k < 2 * N ; k++)  {
        count++;                                          //2N
    }
    int M = 10;
    while ((M--) > 0){
       count++;                                          //10
    }
    System.out.println(count);
}//F(N)=N²+2N+10,使用大O渐近法后，它的时间复杂度是O(N²)。

Func2:
void Func2(int N) {
      int count = 0;
      for (int k = 0; k < 100; k++) {
          count++; 
      }
      System.out.println(count);
 }//基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1)。

Func3:
// 计算BinarySearch的时间复杂度？
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；
 }//基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) 
 PS：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。

Func4:
// 计算阶乘递归Factorial的时间复杂度？
long Factorial(int N) { 
    return N < 2 ? N : Factorial(N-1) * N;
}//基本操作递归了N次，时间复杂度为O(N)。

Func5:
// 计算斐波那契递归Fibonacci的时间复杂度？
long Fibonacci(int N) { 
     return N < 2 ? N : Fibonacci(N-1)+Fibonacci(N-2);
}//现基本操作递归了2^N次，时间复杂度为O(2^N)。

2.空间复杂度
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，也用大O渐近表示
1>. 开辟数组
2>.调用栈
例题：

Func1:
// 计算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]) { 
               Swap(array, i - 1, i); 
               sorted = false; 
            } 
    }
    if (sorted == true) { 
        break; 
    }
  } 
}//使用了常数个额外空间，所以空间复杂度为 O(1)

Func2:
// 计算Fibonacci的空间复杂度？ 
long[] Fibonacci(int n) { 
    long[] fibArray = new long[n + 1]; 
    fibArray[0] = 0; fibArray[1] = 1; 
    for (int i = 2; i <= n ; i++) { 
        fibArray[i] = fibArray[i - 1] + fibArray [i - 2]; 
    }
    return fibArray;
}//动态开辟了N个空间，空间复杂度为 O(N)

Func3
// 计算阶乘递归Factorial的时间复杂度？
long Factorial(int N) { 
    return N < 2 ? N : Factorial(N-1)*N; 
}//递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

3.常见时间/空间复杂度