一.时间复杂度和空间复杂度

1.时间复杂度

衡量一个程序好坏的标准，除了能处理各种异常，还有就是时间效率，当然，对于一些配置好的电脑数据处理起来就是比配置低的高，但从后期发展来看，当数据量足够庞大时，对于时间效率的作用就显得十分重要了。

1.大O渐进表示法

  Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.println("H");
            }
        }
        for (int i = 0; i < n; i++) {
            System.out.println("w");
        }
        for (int i = 0; i < 3; i++) {
            System.out.println("w");
        }

我们来看一下这个代码的运行次数。

运行次数：n*n + n +3

 在计算时间复杂度时我们会优先忽略掉对整体影响不大的值，如该运行次数中的3，我们将其忽略，另外因为n平方为指数函数，相比于n这个常函数，指数函数能更好的表达时间复杂度，所以我们将其忽略。

2.推导方法

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

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

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

具体怎么用呢？

比方说我们的上一个代码时间复杂度就是O（n^2）。

  Scanner scanner = new Scanner(System.in);
        int  n = scanner.nextInt();
        for (int i = 0; i < 2*n; i++) {
            System.out.println("j");
        }
        System.out.println("Hello");

这个代码是：2*n + 1.时间复杂度是O（n）;

for (int i = 0; i < 100; i++) {
            System.out.println("Hello");
        }

运行次数：100，时间复杂度：O（1）;

Scanner scanner = new Scanner(System.in);
        int  n = scanner.nextInt();
        int m = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            System.out.println("j");
        }
        for (int i = 0; i < m; i++) {
            System.out.println("Hello");
        }

运行次数：m+n，时间复杂度：O（m+n）；

  int[] array = {1,2,3,4,5,6,7,8,9,0};
        Scanner scanner = new Scanner(System.in);
        int  n = scanner.nextInt();
        scanner.nextLine();
        int left = 0;
        int right = array.length - 1;
        while(left < right){
            int mid = left + (right - left) / 2 ;
            if ( n > mid){
                left = mid;
            }
            if (n < mid){
                right = mid;
            }
            if (n == mid){
                System.out.println("找到了是：" + mid);
                break;
            }

我们发现次数为x次时，n / 2^x = 1，所以时间复杂度为O（log n） ;

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

次数为n次，所以时间复杂度为O（n）;

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

 

我们发现它实际上是这样执行的我们用红色圈出来的那部分没有遵循我们之前的规则，但由于时间复杂度是估算的，所以我们也就忽略了着误差。我们发现程序执行的次数是一个等差数列，所以我们用到了等差数列的求和公式，再根据大O推到得出时间复杂度为O（N^2）;

空间复杂度

空间复杂度算的是临时开辟了多少空间，多少个变量。

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）；

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

 开辟了N个变量，所以为O（n）;