数据结构--＞时间和空间复杂度

目录

1. 时间复杂度

1.1 概念

1.2 大O的渐进表示法

1.3 推导大O阶方法

1.4 常见时间复杂度计算举例

2. 空间复杂度

2.1 概念

2.2 常见空间复杂度计算举例

---

• 问题引入：我们如何衡量一个算法的好坏呢？

       答：要看算法效率。

算法效率
时间效率（即时间复杂度）	空间效率（即空间复杂度）
衡量一个算法的运行速度	衡量一个算法所需要的额外空间

1. 时间复杂度

1.1 概念

算法的时间复杂度是一个数学函数，它定量描述了该算法的运行时间。

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

问：为什么衡量算法的时间，不能掐表计算

答：这个运行时间与电脑硬件有关，无法准确衡量

1.2 大O的渐进表示法

// 请计算一下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 执行的基本操作次数 ：F(N)=N^2+2*N+10

注意：

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

②大O符号：是用于描述函数渐进行为的数学符号。

1.3 推导大O阶方法

①用常数1取代运行时间中的所有加法常数。

②在修改后的运行次数函数中，只保留最高阶项。

③如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。 

注：大O的渐进表示法是去掉那些对结果影响不大的项，从而简洁明了的表示执行次数，所以使用大O的渐进表示法以后，Func1的时间复杂度为：O(N^2)

当然，有些算法的时间复杂度存在最好、平均和最坏情况：

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

在实际中一般情况关注的是算法的最坏运行情况

1.4 常见时间复杂度计算举例

实例1：

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

F(N)=2*N+10

O(N)

实例2：

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

F(N)=M+N

O(M+N)

实例3：

// 计算func4的时间复杂度
void func4(int N) {
  int count = 0;


  for (int k = 0; k < 100; k++) {
    count++;
  }


  System.out.println(count);
}

F(N)=100

O(1)

实例4：

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

  分析：

1	n-1	结合等差数列求和公式：F（N)=(N^2-N)/2            所以最坏情况下：O(N^2)
2	n-2
3	n-3
n-1	n-(n-1)=1
		最好情况下：只进行一次循环就排序成功，O(N)

实例5：

// 计算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*x）=1 x=log2（N） 即O（log2（N））
第二次N/2
第三次N/4
第四次N/8

实例6：

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

  分析：上述代码没有循环结构，按照

             递归的时间复杂度=递归的次数×每次递归后执行的次数

             因为递归的次数为N次，每次递归后执行的次数为1，所以O（N）

实例7：

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

  分析：

如果出现下述这种情况，结果也不变，因为是按照最坏的情况计算的，并不影响：

2. 空间复杂度

2.1 概念

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

空间复杂度算的是变量的个数，也使用大O渐进表示法。

2.2 常见空间复杂度计算举例

实例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;
    }
  }
}

  分析：

  上述代码中有三个临时变量（int end,int i,boolean sorted）,所以O(1)

实例2：

// 计算fibonacci的空间复杂度
int[] 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有关，n越大，数组越大，所以O(N)

实例3：

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

  分析：

  上述代码中每次调用都开辟一个栈帧，调用了n次，所以O(N)