Java数据结构-准备知识-时间复杂度与空间复杂度

一.算法效率

衡量算法的效率使用时间效率和空间效率用来衡量，时间效率被称为时间复杂度，空间效率被称为空间复杂度，时间复杂度用来衡量算法的运行速度，空间复杂度用来衡量算法所需要的额外空间。随着计算机行业的发展，存储容量不再稀少，空间复杂度也不再重要。

二.时间复杂度

1.时间复杂度的概念：

在计算机科学中，时间复杂度是一个数学函数，定量的描述了该算法的运行时间。一个算法所花费的时间与其中语句执行次数成正比，算法中的基本操作的执行次数，为算法的时间复杂度

注意：时间复杂度表示的是算法运行的最坏情况

2.大O的渐进表示法

方法：1. 当运行次数函数不为常数时，只保留最高阶，且不包含与最高阶相乘的常数

            例如：F(N) = 2N^3 +5      时间复杂度为O(N^3)

            2.当运行次数函数为常数时，时间复杂度为O(1)

            例如：F(N) = 10               时间复杂度为O(1)

3.常见的时间复杂度计算举例

例1：

void func(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);
}

答案：O(n)

例2：

void func(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)

例3：

void func(int N) {
   int count = 0;
   for (int k = 0; k < 100; k++) {
       count++;
  }
   System.out.println(count);
}

答案：O(1)

例4：冒泡排序

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(N^2)

例5：二分查找

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

答案：O(logN)

例6：阶乘递归

long factorial(int N) {
return N < 2 ? N : factorial(N-1) * N;
}

答案：O(N)

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

本题递归N次，每次执行一次

例7：斐波那契数列

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

答案：O(2^N)

常见时间复杂度大小比较：

三.空间复杂度

1.空间复杂度的概念

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

2.常见的空间复杂度计算距离

例1：冒泡排序

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)，使用了常数个变量

例2：斐波那契数列

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

答案：O(N)，动态开辟了N个空间 (i <= n)

例3：阶乘递归

long factorial(int N) {
return N < 2 ? N : factorial(N-1)*N;
}

答案：O(N),递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。