Java—集合框架、时间和空间复杂度

一、集合框架

Java集合框架(Java Collection Framework)，又称为容器(container)，是定义在 java.util 包下的一组接口(interfaces)和其实现类(classes)

其主要表现为将多个元素(element)置于一个单元中，用于对这些元素进行快速、便捷的存储(store)、检索(retrieve）、管理(manipulate)，即俗称的增删查改(CRUD)

类和接口总览

二、时间和空间复杂度

1、概念：

分析算法效率有两种方式：一是时间效率，二是空间效率。时间效率被称为时间复杂度，而空间效率被称为空间复杂度。时间复杂度主要衡量的是一个算法的运行时间，而空间复杂度主要衡量一个算法所需要的额外空间

2、时间复杂度

算法中的基本操作的执行次数，为算法的时间复杂度

一般用大O的渐进表示法来表示时间复杂度

大O符号（Big O notation）：用来描述函数渐进行为的数学符号

推导大O阶的方法

• 1、用常数1取代运行时间中的所有加法常数
• 2、在修改后的运行次数函数中，只保留最高阶项
• 3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数，从而得到大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;
        }
    }
 }

解析：

示例2： 

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

解析：

示例3：

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

 解析：不普适的计算方式：递归的时间复杂度 = 递归的次数 * 每次递归执行的次数

该代码基本操作递归了N次，时间复杂度为O(N)

示例4：

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

解析：

 3、空间复杂度

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

解析：

使用了 end、sorted、i 三个常数个额外空间，所以空间复杂度为O(1)

示例2：

    //计算fibonacci的空间复杂度
    long[] fibonacci(int n) {
        long[] fibArry = new long[n+1];
        fibArry[0] = 0;
        fibArry[1] = 1;
        for (int i = 2; i <= n; i++) {
            fibArry[i] = fibArry[i-1] + fibArry[i-2];
        }
        return fibArry;
    }

解析：

要求n项的斐波那契数，把他们都存放到额外开辟的数组空间中，动态开辟了N个空间，空间复杂度为O(N)

示例3：

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

解析：

看递归了多少次，递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，空间复杂度为O(N)

复杂度大小关系：

O(1) < O(logN) < O(N) < O(N*logN) < O(N^2)