时间和空间复杂度

1. 算法效率

算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间。

---

2. 时间复杂度

2.1 时间复杂度的概念

算法中的基本操作的执行次数，为算法的时间复杂度

// 请计算一下func1基本操作执行了多少次？
void func1(int N){
  int count = 0;
  for (int i = 0; i < N ; i++) {
    for (int j = 0; j < N ; j++) {
      count++;
   }
 }
for (int k = 0; k < 2 * N ; k++) {
    count++;
 }
  int M = 10;
  while ((M--) > 0) {
    count++;
 }
  System.out.println(count);
}

Func1 执行的基本操作次数 ： 

 实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

推导大O阶方法：

1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

使用大O的渐进表示法以后，Func1的时间复杂度为：

---

在平时的复杂度运算中通常有三种复杂度：

最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

而我们平时所说并计算的通常是最坏复杂度。

 2.2 时间复杂度练习

// 计算func2的时间复杂度？
void func2(int N) {
  int count = 0;
  for (int k = 0; k < 2 * N ; k++) {
    count++;
 }
  int M = 10;
  while ((M--) > 0) {
    count++;
 }
  System.out.println(count);
}

2N+10----》O（N）

// 计算func3的时间复杂度？
void func3(int N, int M) {
  int count = 0;
  for (int k = 0; k < M; k++) {
    count++;
 }
  for (int k = 0; k < N ; k++) {
    count++;
 }
  System.out.println(count);
}

O（M+N）

// 计算func4的时间复杂度？
void func4(int N) {
  int count = 0;
  for (int k = 0; k < 100; k++) {
    count++;
 }
  System.out.println(count);
}

100----》O（1）

// 计算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;
     }
   }
}

end----------->[n,n-1,n-2,........,n-(n-1)]

i---------------->[n-1,n-2,...........,1,0]

结果是一个等差数列：（n-1+1）*（n-1）/2；

故最坏情况下：n*（n-1）/2----》(n^2-n)/2取最高阶项时O（n^2）;(逆序数组)

最好情况下：只走了第一个for循环，故时O（n）（顺序数组）

// 计算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;
}

----------------------------------------------------------------------------------- 数量：N

-----------------------------------------                                                   数量：N/2

----------------------                                                                          数量：N/4

故：N/(2^X)=1

                 N=2^X

                 X=LogN;

代表以1为底N的对数。

// 计算阶乘递归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);
}

                                   fib（n）                                             数量:2^0

                       |                            |

                  fib（n-1）           fib（n-2）                                数量:2^1

           |                      |     |                      |

        fib（n-2）   fib（n-3）                                                  数量:2^2

|                                                 

：                                                                                           :

：                                                                                           :

：                                                                                           :

|

fib（1）                                                                                 数量:2^（n-1）

故斐波那契数列项数总和是：2^0+2^1+.......+2^(n-1)

等比数列求和：2^n-1--------->时间复杂度：O(2^n)

---

3. 空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

空间复杂度本质是衡量一个算法浪费内存的情况。

主要找临时占用储存空间的大小。

// 计算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）

// 计算fibonacci的空间复杂度？
int[] fibonacci(int n) {
  long[] fibArray = new long[n + 1];//这里新建了一个数组，而且在随着n的增大而增大。
  fibArray[0] = 0;
  fibArray[1] = 1;
  for (int i = 2; i <= n ; i++) {
  fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
 }
  return fibArray;
}

故空间复杂度是：O（N）

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

因为每次递归都需要压栈现象来保护数据，所以空间复杂度是：O（N）；

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

和时间复杂度不一致的是：一条分支的的两个fib（如上图的n=1和n=2）不能同时存在当完成n=1后才会发生n=0 ，故最大只能有n-1个fib存在

故空间复杂度是：O（n）。