Java 关于时间复杂度和空间复杂度的深度刨析

目录

• 1.算法效率
• 2.时间复杂度

• 2.1时间复杂度的概念
• 2.2大O的渐进表示法
• 2.3常见时间复杂度计算

• 2.3.1常用的时间复杂度量级
• 2.3.2常见示例举例
• 2.3.2示例答案及分析

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

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

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

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

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

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

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