数据结构和算法入门（时间/空间复杂度介绍–java版）
write in front
作者：@ 向大佬学习
专栏：@ 数据结构（java版）
作者简介：大二学生 希望能学习其同学和大佬的经验！
本篇博客简介：主要介绍数据结构的一些概念知识为以后学习打下基础！
今日名言：希望在我们心中，未来是靠双手去创造。
本章目标
一、简单认识集合框架
二、背后所涉及的数据结构合算法
三、时间复杂度
四、空间复杂度
文章目录
- 数据结构和算法入门（时间/空间复杂度介绍--java版）
- 一、简单认识集合框架
- 二、背后所涉及的数据结构合算法
- 1.什么是数据结构
- 2.什么是算法
- 3.算法效率
- 三、时间复杂度
- 1.时间复杂度的概念
- 2.大O的渐进表示法
- 3.推导大O阶方法
- 4.常见时间复杂度计算举例
- 四、空间复杂度
- 1.空间复杂度概念
- 2.常见空间复杂度的计算
一、简单认识集合框架
Java 集合框架 Java Collection Framework，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes 。
其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理manipulate ，即平时我们俗称的增删查改 CRUD.
例如，一副扑克牌(一组牌的集合)、一个邮箱(一组邮件的集合)、一个通讯录(一组姓名和电话的映射关系)等等。
下面的图给出了java中常用集合的继承体系图：
java的集合实际上就是各种基本的数据结构（栈、队列，hash表等）基于业务需求进而演变出的java特有的数据结构。
二、背后所涉及的数据结构合算法
1.什么是数据结构
数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。
用通俗的话来解释数据结构可以理解为：数据+结构。数据是描述客观事物的符号，为程序操控，存储再计算机上，结构包括数据的逻辑和存储结构（物理结构）。
在具体学习容器之前我们先简单了解一下它所对应的特定数据结构的封装。
- Collection：是一个接口，包含了大部分容器常用的一些方法
- List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法
ArrayList：实现了List接口，底层为动态类型顺序表
LinkedList：实现了List接口，底层为双向链表- Stack：底层是栈，栈是一种特殊的顺序表
- Queue：底层是队列，队列是一种特殊的顺序表
- Deque：是一个接口
- Set：集合，是一个接口，里面放置的是K模型
HashSet：底层为哈希桶，查询的时间复杂度为O(1)
TreeSet：底层为红黑树，查询的时间复杂度为O(logN ),关于key有序的- Map：映射，里面存储的是K-V模型的键值对
HashMap：底层为哈希桶，查询时间复杂度为O(1)
TreeMap：底层为红黑树，查询的时间复杂度为O(logN )，关于key有序
2.什么是算法
算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
3.算法效率
算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间。
在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
三、时间复杂度
1.时间复杂度的概念
时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个数学函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
2.大O的渐进表示法
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
3.推导大O阶方法
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
另外有些算法的时间复杂度存在最好、平均和最坏情况,在实际中一般情况关注的是算法的最坏运行情况。
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);
}
根据循环可得，基本操作执行了2*N+10次，通过推导大O阶的方法得到时间复杂度是O（N）。
[实例2]
//计算func3的时间复杂度？
void func3(int N, int M) {
int count = 0;
for (int k = 0; k < M; k++) {
count++;
}
for (int k = 0; k < N ; k++) {
count++;
}
System.out.println(count);
}
根据循环可得，基本操作执行了M+N次，由于M和N都是未知的，通过推导大O阶的方法得到时间复杂度是O（M+N）。
[实例3]
//计算func4的时间复杂度？
void func4(int N) {
int count = 0;
for (int k = 0; k < 100; k++) {
count++;
}
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;
}
}
}
(1)最好情况：排序的数组本来就是有序的，那么外层循环只会执行一次，而内层循环会执行N次，所以得到的时间复杂度是O（N）。
(2)最坏情况，数组是完全无序的，那么外层循环合内层循环都会执行N次，内层循环执行次数从N开始，每次减少1，构成一个等差数列。
因为复杂度的计算都是看最坏情况：执行了1/2*N2+1/2次，通过推导大O阶的方法得到时间复杂度是O（N2）。
[实例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次(要找的那个数恰好在中间，第一次就找到)
最坏情况：基本操作执行log2N次（以2为底）
下面的图是解释
2x=N, x=log2N,所以时间复杂度是O（logN）。
[实例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);
}
计算时间复杂度并不一定要精准计算基本操作数，当N足够大时，左边缺少的一部分就可以忽略不计，
所以根据等比数列求和公式可得：2N-1,通过推导大O阶的方法得到时间复杂度是O（2N）。
四、空间复杂度
1.空间复杂度概念
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。
2.常见空间复杂度的计算
[实例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)。
[实例4]
//计算阶乘递归Factorial的空间复杂度？
long fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}
通过观察上面的图进行分析，每次递归都会开辟对应的栈帧并将参数压栈，这里需要注意的是每次每次递归调用结束后，相应的栈帧空间会被销毁释放，不计入空间复杂度中。
当一次递归又分为两次递归调用时，只有左边的调用返回后才执行右边的调用。
所以图中的每一层其实最终只有一个栈帧空间，所以求第N个斐波那契数列的递归深度为N,也就是开辟了N个栈帧
每次递归的栈帧空间大小都是一样的，所以每次递归中所需的空间是个常量，并不会随着N的变化而变化，每次递归的空间复杂度就是O（1）.
开辟N个栈帧，每个栈帧使用了常数个空间累加，所以最终的空间复杂度为O(N).
![[算法很美打卡第四天] 字符串篇(中)](https://img-blog.csdnimg.cn/9f87966b918d4edfae94e5e79805ad91.png)
