Java时间复杂度与空间复杂度

时间复杂度

1. 概念

一个算法所花费的时间与其中语句的执行次数成正比,算法中的基本操作的执行次数,为算法的时间复杂度.

2.时间复杂度存在情况

时间复杂度存在最好,平均和最坏情况.

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

例如: 在一个长度为N数组中搜索一个数x
最好情况: 1次找到
最坏情况: N次找到
平均情况: N/2次找到

平时我们主要着重于时间复杂度的平均情况和最坏情况.
在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)

3.大O的渐进表示法

实际中我们计算时间复杂度时,不一定要计算精确的执行次数,只需要大概执行次数,那么这个时候我们可以使用大O的渐进表示法.

(1)大O符号(Big O notation): 是用于描述函数渐进行为的数学符号
(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循环运行 N * N 次
   for (int k = 0; k < 2 * N ; k++) {
   count++;
   }//这个for循环运行 N 次
   int M = 10;
   while ((M--) > 0) {
        count++;
   }//这个操作运行 10 次
   System.out.println(count);
}

func1执行的基本操作次数:

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

那么func1的时间复杂度为: O(N ^ 2)

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

该例子基本操作执行了2N + 10次,由大O阶方法得,时间复杂度为O(N)

(2)

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

时间复杂度为O(M + N)

(3)

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

该例子基本操作执行了100次,由大O阶方法得,时间复杂度为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;
          }
       }
}

该例子基本操作执行最好N次,最坏执行了(N * (N - 1)) / 2次,又因为时间复杂度一般看最坏情况,由大O阶方法得,时间复杂度为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;
}

该例子基本操作执行最好1次,最坏O(logN)次,时间复杂度为O(logN)

ps: logN在算法分析中表示是底数为2,对数为N

(6)

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

该例子基本操作递归了N次,时间复杂度为O(N)
(7)

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

该例子基本操作递归了2 ^ N次,时间复杂度为O(2 ^ N)

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度,也使用大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;
     }
 }
}

该例子使用了常数个额外空间,所以空间复杂度为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个空间,空间复杂度为O(N)

(3)

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

该例子递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间,空间复杂度为O(N)