【数据结构】时间复杂度与空间复杂度

目录

一、时间复杂度

1、大O阶方法

（1）大O阶方法的表示方法

（2）最好、最坏和平均时间复杂度

（3）冒泡排序

（4） 折半查找

（5）关于递归算法的执行时间分析

二、空间复杂度

（1）冒泡算法

（2）循环斐波那契

（3）递归函数的空间复杂度

---

数据结构：计算机存储在组织的数据的方式。数据结构关心的是数据怎么高效读写的问题。

算法：在特定的数据及上进行的一系列计算步骤。算法关心的是数据怎么使用的问题（不关心具体数据的读写）。

数组->数据结构，数组关心的问题就是元素如何存储到当前结构中，之余存进来的元素有啥作用以及如何使用，并不关心。

排序算法->关心的是在一组数据中，如何按照我的步骤，将这一组数据变为有序的数据=》数据的使用。

如何评价一个算法的好坏：两种维度：时间效率和空间效率。

一、时间复杂度

时间复杂度：主要衡量一个算法的运行速度。

不是具体的时间，在计算机领域其实是一个数学函数。因为不同计算机硬件不同，相同的算法在不同的CPU，内存这些硬件上具体执行的时间都会有差异，而且有可能差异很大。

所以利用一个数学函数，描述一个算法的基本操作的执行次数就是我们讨论的时间复杂度。

    public static void func(int N){
        int count = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0;j<N;j++){
                count++;
            }
        }
        for (int i = 0; i < 2 * N; i++) {
            count++;
        }
        int M = 10;
        while(M>0){
            count++;
            M--;
        }
        System.out.println(count);
    }

 当输入的N为1000时，输出的结果是1002010。count = N*N+2*N+10.当N越来越大的时候N*N对于count的影响越来越大，剩下两项可以忽略不计，时间复杂度就为O（N²）。

 时间复杂度不一定要统计具体的执行次数，只需要描述出算法的大概执行次数，保留对算法影响最大的某一项即可，该项就可以表示出该算法的时间效率。

1、大O阶方法

（1）大O阶方法的表示方法

用常数1来代表函数中所有的加法常数（只要是常数，常量，都是1无论常量有多大都用1代替）因为常量和输入数值N变量毫无关系，此算法是一个稳定的时间效率算法，和变量无关。

只保留函数的最高阶项，所有低阶省略不计。

若最高阶项存在，且项数不为1，统一都将最高阶项的项数看做1。

（2）最好、最坏和平均时间复杂度

一个算法的时间复杂度存在最好、最坏和平均时间复杂度。

最坏：任意输入的数据，最大的执行次数（算法的上界）。

最好：任意输入的数据，最小的执行次数（算法的下界）。

平均：任意输入的数据，平均执行次数。

衡量一个算法的时间复杂度去上界，一般都看最坏情况，使用大O阶时间复杂度来描述整个算法的时间复杂度。

    public static void func1(int N,int M){
        int count = 0;
        for (int i = 0; i < M; i++) {
            count++;
        }
        for (int i = 0; i < N; i++) {
            count++;
        }
        System.out.println(count);
    }

大O阶看的是变量的最高阶，若存在多个输入变量，都需要保留各个变量的最高阶，此时N和M都是变量，无法得知谁大谁小，推倒大O阶时M和N都保留其最高阶，所以时间复杂度是O（M+N）。

（3）冒泡排序

public static void bubbleSort(int[] arr){
        for(int i = 0;i<arr.length-1;i++){
            for(int j = 0;j<arr.length-1-i;j++){
                if(arr[i]>arr[j]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }

 因为他内外层循环都执行N次，所以冒泡排序的时间复杂度是O（n²）。

（4） 折半查找

    public static int binSearch(int[] arr,int value){
        int left = 0;
        int right = arr.length;
        while(left<=right){
            int mid = left+((right-left)>>1);
            if(value<arr[mid]){
                right = mid-1;
            }else if(value>arr[mid]){
                left = mid+1;
            }else{
                return mid;
            }
        }
        throw new NoSuchFieldException("没有找到该元素！")
    }

这里的循环并不是简单的从0走到N-1。此处每次从区间的中间位置将区间一分为二，所以执行次数为以2位底N的对数。用大O阶表示时可以忽略底数。时间复杂度为O（logn）。

如何分析一个算法是对数级别的时间复杂度：如果算法是不断的将一个变量N/2也罢，N/3也罢，一直除到0或者1，这个算法一定是一个对数级别算法。一个算法若能做到对数级别的时间复杂度，非常优秀。

快速排序的算法是O（nlogn）。

（5）关于递归算法的执行时间分析

    public static int fib(int N){
        return N<=2? N:fib(N-1)+fib(N-2);
    }

 将fib递归函数展开，执行次数就是下图中方框的总个数，就是求二叉树的节点个数，为2^N+1。所以时间复杂度是O（2^N）。

    public static int factor(int N){
        if (N <= 2 ){
            return N;
        }
        return N*fib(N-1);
    }

展开就成了N*N-1*N-2*N-3*N-…… 3*1，这就是个循环从1……N依次展开循环。所以时间复杂度为O（n）。

二、空间复杂度

空间复杂度：主要衡量一个算法正常执行所需要的额外空间大小，不是当前数据集本身占用的空间所谓的额外空间：为了解决这个问题，新开辟的内存大小。

空间复杂度描述一个算法额外开辟的临时变量个数，也是使用大O渐进表示法来描述空间复杂度。

（1）冒泡算法

arr是本身要解决的问题，不是为了解决冒泡排序新开辟的新空间，在解决arr数组排序问题中，只开辟了一个临时变量tmp。

所以空间复杂度与传入的数组无关，与变量无关，所以空间复杂度为O（1）。

（2）循环斐波那契

public static int[] fib(int N){
        int[] ret = new int[N+1];
        ret[0] = 1;
        ret[1]= 1;
        for(int i = 2;i<=N;i++){
            ret[i] = ret[i-1]+ret[i-2];
        }
        return ret;
    }

在方法内部的第一行就开辟了新的数组ret ，所以空间复杂度为O（n）。

（3）递归函数的空间复杂度

    public static int facter(int N){
        return N<=2? N: facter(N-1)*N;
    }

对于递归函数来说，每次执行一次函数，就会在系统栈上产生新的栈帧，这就属于临时空间。所以这个求阶乘的递归方法空间复杂度为O（n）。

空间复杂度就看函数内部new了什么--非递归时。

递归函数还是看展开次数，每次调用一次函数，都会在栈上开辟栈帧空间。