标签：语句 20211116 right datawhale31 复杂度 算法 时间 leetcode left
0 序言及预习
目录
来源
Datewhle31期__LeetCode 刷题 :
-
航路开辟者：杨世超
-
领航员：刘军
-
航海士：杨世超、李彦鹏、叶志雄、赵子一
-
开源电子书
https://algo.itcharge.cn
1 数据结构与算法
- 算法(Algorithm)*就是解决问题的方法或者过程
- 数据结构（Data Structure） 是数据的计算机表示和相应的一组操作。程序（Program） 则是算法和数据结构的具体实现。
目的 : 对于待解决的问题，我们追求的是：选择更加合适的「数据结构」，使用花费时间更少、占用空间更小的「算法」
关于算法和数据结构自己总结:
1 数据结构，我们可以按照数据的 「逻辑结构」 和 「物理结构来进行分类。
-
物理结构（Physical Structure）：数据的逻辑结构在计算机中的存储方式。
计算机内有多种存储结构，采用最多的是这两种结构：顺序存储结构、链式存储结构。
关于逻辑和物理结构详情总结:
2 算法
-
算法 指的就是解决问题的方法。算法是一系列的运算步骤，这些运算步骤可以解决特定的问题。
-
算法拥有 5 个基本特性：输入、输出、有穷性、确定性、可行性。
-
算法追求的目标有 5 个：正确性、可读性、健壮性(对非法数据以及操作有较好的反应和处理)、所需运行时间更少（时间复杂度更低）、占用内存空间更小（空间复杂度更低）。
2 算法复杂度
- 算法复杂度（Algorithm complexity）：在问题的输入规模为 n 的条件下，程序的时间使用情况和空间使用情况。
2.1 时间复杂度
时间复杂度（Time Complexity）：在问题的输入规模为 n 的条件下，算法运行所需要花费的时间，可以记作为 T(n)。
我们将基本操作次数作为时间复杂度的度量标准。换句话说，时间复杂度跟算法中基本操作次数的数量正相关。
基本操作 ：算法执行中的每一条语句。每一次基本操作都可在常数时间内完成。
- 由简单的数学知识可知, 时间复杂度可用O表示: T(n) = O(f(n)), 表示为随n增大, 算法执行时间的增长趋势跟 f(n)相同。 O是一种渐进符号， T(n)称作算法的 渐进时间复杂度（Asymptotic time complexity），简称为 时间复杂度。
「渐进符号」 实际上是专门用来刻画函数的增长速度的, 常忽略低阶幂、系数、常量不影响规模大时增长速率的部分, 常用 Θ , O , Ω \Theta, O, \Omega Θ,O,Ω表示渐进的: 上下限(夹逼准则), 上限, 下限.
- 作为算法只关心------上界.
- 求O的一般步骤:
- 找出算法中的基本操作（基本语句）：算法中执行次数最多的语句就是基本语句，通常是最内层循环的循环体部分。
- 计算基本语句执行次数的数量级：只需要计算基本语句执行次数的数量级，即保证函数中的最高次幂正确即可。像最高次幂的系数和低次幂可以忽略。
- 用大 O 表示法表示时间复杂度：将上一步中计算的数量级放入 O 渐进上界符号中。
- 注意一些运算法则:
-
加法: 总的时间复杂度等于量级最大的基本语句的时间复杂度。
- 即: 如果
T
1
(
n
)
=
O
(
f
1
(
n
)
)
，
T
2
=
O
(
f
2
(
n
)
)
,
T
(
n
)
=
T
1
(
n
)
+
T
2
(
n
)
T_{1}(n)=O\left(f_{1}(n)\right) ， T_{2}=O\left(f_{2}(n)\right), T(n)=T_{1}(n)+T_{2}(n)
T1(n)=O(f1(n))，T2=O(f2(n)),T(n)=T1(n)+T2(n) ，则
T ( n ) = O ( f ( n ) ) = max ( O ( f 1 ( n ) ) , O ( f 2 ( n ) ) ) = O ( max ( f 1 ( n ) , f 2 ( n ) ) ) 。 T(n)=O(f(n))=\max \left(O\left(f_{1}(n)\right), O\left(f_{2}(n)\right)\right)=O\left(\max \left(f_{1}(n), f_{2}(n)\right)\right) 。 T(n)=O(f(n))=max(O(f1(n)),O(f2(n)))=O(max(f1(n),f2(n)))。
- 即: 如果
T
1
(
n
)
=
O
(
f
1
(
n
)
)
，
T
2
=
O
(
f
2
(
n
)
)
,
T
(
n
)
=
T
1
(
n
)
+
T
2
(
n
)
T_{1}(n)=O\left(f_{1}(n)\right) ， T_{2}=O\left(f_{2}(n)\right), T(n)=T_{1}(n)+T_{2}(n)
T1(n)=O(f1(n))，T2=O(f2(n)),T(n)=T1(n)+T2(n) ，则
-
乘法原则：循环嵌套代码的复杂度等于嵌套内外基本语句的时间复杂度乘积
- 如果 T 1 = O ( f 1 ( n ) ) , T 2 = O ( f 2 ( n ) ) , T ( n ) = T 1 ( n ) T 2 ( n ) T_{1}=O\left(f_{1}(n)\right), T_{2}=O\left(f_{2}(n)\right), T(n)=T_{1}(n) T_{2}(n) T1=O(f1(n)),T2=O(f2(n)),T(n)=T1(n)T2(n) ， 则 T ( n ) = O ( f ( n ) ) = O ( f 1 ( n ) ) O ( f 2 ( n ) ) = O ( f 1 ( n ) f 2 ( n ) ) T(n)=O(f(n))=O\left(f_{1}(n)\right) O\left(f_{2}(n)\right)=O\left(f_{1}(n) f_{2}(n)\right) T(n)=O(f(n))=O(f1(n))O(f2(n))=O(f1(n)f2(n))
-
-
一些常见时间复杂度:
- O(1) : 不存在循环语句、递归语句
- O(n) : 含有非嵌套循环，且单层循环下的语句执行次数为 n 的算法涉及线性时间复杂度, 算法规模随n增大呈线性增长.
- O ( n 2 ) O(n^2) O(n2): 一般含有双层嵌套，且每层循环下的语句执行次数为 n 的算法涉及平方时间复杂度, 算法规模随n增大呈平方增长.
- O(n!) : 阶乘时间复杂度一般出现在与「全排列」相关的算法中。这类算法随着问题规模 n 的增大，对应计算次数呈阶乘关系增长。
- O ( l o g 2 n ) O(log_2n) O(log2n) : 对数时间复杂度一般出现在「二分查找」、「分治」这种一分为二的算法中。这类算法随着问题规模 n 的增大，对应的计算次数呈对数关系增长。
- O ( n l o g 2 n ) O(n log_2 n) O(nlog2n): 线性对数一般出现在排序算法中，例如「快速排序」、「归并排序」、「堆排序」等。这类算法随着问题规模 n 的增大，对应的计算次数呈线性对数关系增长
-
排序: 根据从小到大排序，常见的算法复杂度主要有: O ( 1 ) < O ( log 2 n ) < O ( n ) < O ( n log 2 n ) < O ( n 2 ) < O(1)<O\left(\log _{2} n\right)<O(n)<O\left(n \log _{2} n\right)<O\left(n^{2}\right)< O(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)< O ( n 3 ) < O ( 2 n ) < O ( n ! ) < O ( n n ) O\left(n^{3}\right)<O\left(2^{n}\right)<O(n !)<O\left(n^{n}\right) O(n3)<O(2n)<O(n!)<O(nn)
- 最佳, 最糟, 平均时间复杂度:
- 最佳时间复杂度：每个输入规模下用时最短的输入所对应的时间复杂度。
- 最坏时间复杂度：每个输入规模下用时最长的输入所对应的时间复杂度。
- 平均时间复杂度：每个输入规模下所有可能的输入所对应的平均用时复杂度（随机输入下期望用时的复杂度）。----- 所有情况总和除以情况数量
2.2 空间复杂度
空间复杂度（Space Complexity）：在问题的输入规模为 n 的条件下，算法所占用的空间大小，可以记作为 S(n)。一般将 算法的辅助空间 作为衡量空间复杂度的标准。
-
空间复杂度的函数可以表示为S(n) = O(f(n)) ，它表示的是随着问题规模 n 的增大，算法所占空间f(n)的增长趋势跟 相同。------------ 主要包括「局部变量（算法范围内定义的变量）所占用的存储空间」和「系统为实现递归（如果算法是递归的话）所使用的堆栈空间」两个部分。
-
排序:常见的算法复杂度主要有: O ( 1 ) < O ( log 2 n ) < O ( n ) < O ( n 2 ) < O ( 2 n ) O(1)<O\left(\log _{2} n\right)<O(n)<O\left(n^{2}\right)<O\left(2^{n}\right) O(1)<O(log2n)<O(n)<O(n2)<O(2n)
3 leetcode
-
推荐刷题顺序:
1.初级算法
2.数组类算法
3.数组和字符串
4.链表类算法
5.哈希表
6.队列 & 栈
7.递归
8.二分查找
9.二叉树
10.中级算法
11.高级算法
12.算法面试题汇总 -
自己LeetCode的第一题---------------两数之和:
- 暴力
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
size = len(nums)
for i in range(size):
for j in range(i + 1, size):
if nums[i] + nums[j] == target:
return [i,j]
return[]
2.哈希—字典:
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
size = len(nums)
dic = {}
for i in range(size):
if target - nums[i] in dic:
return [i,dic[target - nums[i]]]
dic[nums[i]] = i # 没找到符合条件 使用字典存值及下标 省去再次遍历下次直接访问
return []
- 结果对比
标签：语句,20211116,right,datawhale31,复杂度,算法,时间,leetcode,left 来源： https://blog.csdn.net/yuliuchenyin/article/details/121353935
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。