Java数据结构之时间复杂度和空间复杂度

0引言

Java数据结构学什么？除了学习一些数据结构前置知识，还要学习Java集合与数据结构。

什么是数据结构？

描述和组织数据。

什么是集合？

Java会把一些数据结构封装起来。

推荐书籍：《大话数据结构》封清扬老师

推荐理由：图文结合，大白话讲解数据结构

数据结构与算法什么关系？

相辅相成。

数据库与数据结构有什么关系？

数据库底层存储数据，使用的其实也是数据结构，比如树等。

如何学好数据结构？

方法：1.多写代码

           2.多思考

           3.多画图

数据结构锻炼的是逻辑思维能力，最重要的是理解其中思想。

0 时间复杂度和空间复杂度

1.算法效率

时间效率和空间效率，即时间复杂度和空间复杂度。时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间。

2.时间复杂度

（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

我们发现N越大，+10就不那么重要了。

实际计算时我们不用计算精准次数，只需要大概执行次数，那么这里我们使用大O的渐进表示法。大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

这个题的O阶是：O（N^2）

（3）推导O阶方法

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

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

我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

另外注意，在实际中一般情况关注的是算法的最坏运行情况（最多运算次数、上限）。

常见的渐进时间复杂度比较：

Ο(1)或Ο(M)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜Ο(2n)<Ο(n!)<Ο(nn)

例题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);
}

例1中基本操作执行次数为：2N+10，根据大O阶方法得时间复杂度为：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);
}

例2中基本操作执行次数为：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);
}

例3中基本操作执行次数为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;
   }
 }
}

例4是冒泡排序的操作，其中每排序一次，程序依次执行n-1次，n-2次，n-3次，一直到程序只执行1次，冒泡排序完成。我们可以发现，将执行次数反过来看正好是一个等差数列，用等差数列求和公式（（（首项＋末项）*项数）/2）可以算出最终程序执行次数为(1/2)*n^2-n/2，运用大O阶方法推出时间复杂度为O（N^2），注意，这是最差情况。最好的情况是程序只排序一次就排好序了，这是程序执行了N次，时间复杂度就是O（N）。又因为时间复杂度一般看最差情况，则该冒泡排序的时间复杂度为O（N^2）

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

例5是一个二分查找问题。我们可以考虑最坏情况是什么情况，就是要查找的数最后一个被找到。我们可以设查找次数为第y次，一共n个数据，每次查找完，新的查找范围为n/y，比如一次二分剩下：n/2，两次二分剩下：n/n/2=n/4，我们会发现2^y=n，可以得到查找次数y=log2n；由大O阶算法得时间复杂度为O（log2N）

例题6

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

例6是阶乘递归问题，时间复杂度=递归次数×每次递归后执行的次数。该题中的三目运算符，每次递归后执行次数为1次，我们就只用算递归次数就好，我们发现递归次数为N-1次，由大O阶得出则此题时间复杂度为O（N）

例题7

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

例7为斐波那递归。具体分析过程看下图。

3.空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

空间复杂度也使用大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;
   }
}
}

1. 实例1使用了常数个额外空间，所以空间复杂度为 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;
}

2. 实例2动态开辟了N个空间，空间复杂度为 O(N)

例题3

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

3. 实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)