软件设计学习笔记

最新推荐文章于 2024-09-11 17:19:24 发布

termandy

最新推荐文章于 2024-09-11 17:19:24 发布

阅读量905

点赞数 9

文章标签：学习

本文链接：https://blog.csdn.net/weixin_44497507/article/details/135677785

版权

进制

进制	数码	基数	位权
十进制（D）	0-9	10	$10^k$
二进制（B）	0-1	2	$2^k$
十六进制（H）	0-9，A-F	16	$16^k$

按权展开法

数码*位权，整数从k从0开始，小数从-1开始。

进制转换

8421法：二进制转八进制、转十六进制

二进制	10	001	110
八进制	2	1	6

二进制	1000	1110
十六进制	8	E

码制

	数值1	数值-1	数值1加数值-1	结果（10进制）
原码	0000 0001	1000 0001	1000 0010	-2
反码	0000 0001	1111 1110	1111 1111	-0
补码	0000 0001	1111 1111	0000 0000	0
移码	1000 0001	0111 1111	1000 0000	-0

范围

码制	定点整数	定点小数	数码个数
原码	$\pm 2^{n-1}-1$	$\pm(1- 2^{-(n-1)})$	$2^{n-1}$
反码	$\pm 2^{n-1}-1$	$\pm(1- 2^{-(n-1)})$	$2^{n-1}$
补码	$-2^{n-1}$ 到 $2^{n-1}-1$	$-1$ 到 $1- 2^{-(n-1)}$	$2^n$
移码	$-2^{n-1}$ 到 $2^{n-1}-1$	$-1$ 到 $1- 2^{-(n-1)}$	$2^n$

浮点

N=尾数*基数^指数（阶码）

$1.25*10^6$ 1.25定点小数。10基数.6阶码（定码整数）

$1.255*10^{10}$ 阶码，表示数值的范围。

运算过程：对阶-尾数计算-结果格式化

特点：

一般尾数用补码，阶码用移码
阶码的数位的表示范围，越大表示数的范围越大
尾数表示有效精度，位数越多，精度越高
对阶时，小数向大数看齐
对阶是通过较小数的尾数右移实现的

逻辑运算

关系运算

<、<=、>、>= 优先级高

!=、== 优先级低

赋值<关系<算术

逻辑运算

逻辑或	\|\| + U V OR	只要有一个为真结果为真
逻辑与	：&& * . $\cap \wedge$ AND	全为真结果为零真
逻辑异或	$\bigoplus$ XOR	相同为0，不同为1
逻辑非	！、~、 NOT、-	原结果取反

A	B	！A	A+B	A*B	A $\bigoplus$ B
0	0	1	0	0	0
0	1	1	1	0	1
1	0	0	1	0	1
1	1	0	1	1	0

优先级！>&&> ||

!>算术>关系>&&>||>赋值

先做	！
算术	+-*/
关系	> 、>=、 < 、<= 、== 、!=
逻辑	&&、\|\|

短路原则：

a&&b&&c ,当a为假时，后面不需要判断

a||b||c，当a为真，后面不需要判断

校验码

基本概念

码距

任何一种编码都由许多码字构成，任意两个码字之间最少的变化的二进制们数就称为数据校验的码距。

奇偶

由若干位有效信息，再加上一个二进制位（校验位组成）

只能检查出奇数位1位的错误

CRC

在信息位后面，拼接r位校验码。可检错，不可纠错。

r是生成多项式决定。发送方和接收方提前约定。方法是模二除法。余数为0则正确。

海明

多组，分组奇偶校验。可检错，也可纠错。

公式： $2^r\geqslant m+r+1$

m是多少位

	校验码位数	校验码位置	检错	纠错	校验方式
奇偶	1	前或后	可检奇数位	否
CRC	多项式	尾	是	否	模二除法
海明	$2^r\geqslant m+r+1$	2的次方式(n从0）	是	是	分组奇偶

CPU构成

运算器

算术逻辑单元 ALU：数据的算术运算和逻辑运算
累加寄存器AC：通用寄存器，为ALU提供一个工作区，用于暂存数据
数据缓冲寄存器DR：写内存时，暂存指令或数据
状态条件寄存器PSW：存状态标志与控制标志（争议：也有将期归类为控制器）

控制器

程序计数器PC：存储下一条要执行指令的地址
指令寄存器IR：存储即将执行的指令
指令译码器ID：对指令中的操作码字段进行分析解释
时序部件：提供时序控制信号

寻址方式

立即寻址：操作数直接在指令中，速度快，灵活性差

直接寻址：指令中存放的是操作数的地址

间接寻址：指令中存放一个地址，这个地址对应的内容是操作数的地址

寄存器寻址：寄存器存放操作数

寄存器间接导址：寄存器存放操作数的地址

CISC与RISC

指令系统类型

指令

寻址方式

实现方式

其它

CISC

数量多，可变长

支持多种

微程序控制（微码）

研制周期长

RISC

数量少，定长，操作寄存器

支持方式少

增加了通用寄存器

硬件布线逻辑控制为主

适合流水线

优化线路

有效支持高级语言

流水线

计算公式：1条指令执行时间+（指令条数-1）*流水线周期

理论公式： $(t_1+t_2+t_k)+(n-1)*t$

实践公式： $k*t+(n-1)*t$ .k表示一个周期划分成几段，一般是三段。提取、分析、执行

存储系统

层次化存储

特点

局部性原理是层次化存储结构的支撑

时间局布性：刚被访问的内容，立即又被访问

空间局布性：刚被访问的内容，礼金的空间很快被访问

CPU	速度快	容量小	成本高
Cache
内存				随机存储RAM 只读存储ROM
外存	速度慢	容量大	成本小

Cache

访问速度：寄存器>Cache>内存>外存

原理：使用了时间局部性和空间局部性

命中率：

t1=Cache的周期时间，t2=主存储器周期时间。

t3=平均周期

1-h=失效率

t3=h*t1+(1-h)*t2

	电路复杂度	冲突率
直接相联映像	简单	高
全相联映像	复杂	低
组相联映像	中	中

主存编址计算

存储单元：个数=最大地址-最小地址+1

编址内容：最小寻址单位是一个字节

总容量=存储单元个数*编址内容

总片数=总容量*每片的容量

数据量：1K=2^10 1M=2^10K 1G=2^10M 1B=8bit

数据传输控制方式

程序控制（查询）方式：

分为无条件传送和程序查询方式。方法简单，硬件开销小，但IO能力不高，严重影响CPU的利用率。

程序中断试：中断方式因为CPU无需等待，提高了传输请求的响应速度。

DMA方式：在主存与外设之间实现高速、批量数据交换。DMA比程序控制和中断都高效。

通道方式：

IO处理机：

从下到下，处理处理越来越高。

中断处理过程：

CPU无需等待也不必须查询IO状态

当OI系统准备好以后，发出中断请求信息，通知CPU

CPU接到中断请求后，保存正在执行的程序现场（保存现场），打断的程序当前位置为断点

通过中断向量表，转入IO中的服务程序的执行，完成IO系统的数据交换

返回被打断的程序继续执行

总线

一条总线同一时刻，仅请允许一个设备发慈禧太后，但允许多个设备接收

数据总线：Data Bus,在CPU与RAM之间来回传送需要处理或是需要储存的数据

地址总线：Address Bus,用来指定RAM这中储存数据的地址

控制总线：Control Bus，将微处理器控制单独的信号，传送到周边设备

可靠性

平均无故障时间 MTTF

平均故障修复时间 MTTR

平均故障间隔时间 MTBF

系统可用性 MTTF/(MTTR+MTTF)*100%

串联系统

整体系统可行性： $R=R_1*R_2*\cdots R_n$

并联系统

整体可靠性： $R=1-(1-R_1)*(1-R_2)\dots(1-R_n)$

性能指标

字长和数据通路宽度

主存容量和存取速度

运算速度

吞吐量与吞吐率

响应时间（RT）与完成时间（TAT）

兼容性

主频与CPU时钟周期

CPI与IPC

MIPS与MFLOPS

主频：2.4GHZ，表示1秒中有2.4G次脉冲

时钟周期：主频的倒数，单位是秒。

CPI:clock per instruction,平均每条指令的平均时钟周期个数。周期/指令

IPC，表示每个时间周期能完成的指令条数。

MIPS：M表示百万，I表示指令。P表示每，S表示秒。

MFLOPS，M表示百万，FLO表示浮点数，P、S表示每秒。

数：1K=10^3,1M=10^3K=10^6,1G=10^3M=10^6K=10^9

操作系统

从底层开始排序：硬件-操作系统-语言处理-应用程序

特殊的操作系统

分类	特点
批处理操作系统	单道批：一次一个作业存入内存，作业由程序、数据、作业说明书组成多道批：一次多个作业入内存，特点，多道宏观上并行，微观上串行
分时操作系统	采用时间片轮转的方式，为多个用户提供服务，每个用户感觉独占系统特点：多路性，独立性，交互性和及时性
实时操作系统	实时控制系统和实时信息系统交互能力要求不高，可靠性要求高（规定时间内响应并处理）
网络操作系统	方便有效共享网络资源，提供服务软件和有关协议的集合
分布式操作系统	任意两台计算机可以通过通信交换信息是网络操作系统的更高级形式
微机操作系统	windows/linux 图形界面，多任务
嵌入性操作系统	运行在智能芯片的环境中特点：微型化、可定制（针对硬件变化配置）、实时性、可靠性、易移植性（HAL、BSP）

线程

进程是程序在一个数据集合上的运行过程，它是系统进行资源分配和调度的一个独立单位。它由程序块、进程控制块（PCB）和数据块三部分组成。

PCB：是进程存在的唯一标志，内容包含进程标识符，状态、位置信息、控制信息、队列指针、优先级、现场保护区。

进程

程序是一个静态概念，进程是一个动态的概念。

一个进程可包含多个线程。

进程：可拥有独立资源，可独立调度和分配的资源的基本单位。

进程可共享：内存地址空间、代码、数据、文件。

进程不可共享：寄存器、程序计数器、栈。

三太模型：运行-就绪-等待

运行：当一个进程在CPU上运行时，单处理机处于运行的的进程只有一个。

就绪：一个进程获得了除CPU外的一切所需要资源，一但得到处理机即可运行。

等待（阻塞）：也称等待、睡眠状态，一个进程正在等待某一个事件发生（例如请求IO、等待IO完成）而暂时停止运行。此时即使把CPU分配给进程也无法运行，帮称进程处理阻塞状态。

等待状态：不会直接到运行，就绪状态，也不会返回到等待。

PV操作

临界资源：诸进程间需要互斥方式对其进行共享的资源。进程中访问临界资源的那估代码称为临界区。

互斥：间接制约的关系。

同步：速度有差异，在一定情况下等待，直接制约关系

互斥与同步，并不是相反的关系

信息号：是一种特殊的变量，信号量可以表示资源数量，信息量为负数时还可以表示排队进程数

P操作，申请资源，加锁。V操作，释放资源，解锁。

P操作，S=S-1,如果S<0,进阻塞。S=0的时候，资源是满足的。

V操作，S=S+1,如果S<=0,释放阻塞。否则执行进程。

死锁

条件：

互斥
保持和等待
不剥夺
环路等待

不可能发生死锁的最小资源数：

w: 需要的资源数

m: 进程数

n:资源数

(w-1)*m+1<=n

进程资源图

$P\rightarrow R$ 表示程序申请资源

$R\rightarrow P$ 表示资源分配给程序

段页式存储

页式存储

将程序与内存均划分为同样大小的块，以页为单位将程序调用内存

程序：

逻辑页		页表		物理页
逻辑页号	逻辑地址	逻辑页号	物理页号	物理页号	物理地址
0	0	0	5	0	0
	1	1	2		1
	2	2	10		2
	3	3	9		3
1	4			1	4
	5				5
	6				6
	7				7
2	8			2	8
	9				9
	10				10
	11				11
3	12			3	12
	13				13
	14				14
	15				15
				4	16
					17
					18
					19
				5	20
					21
					22
					23
				6	24
					25
					26
					27
				7	28
					29
					30
					31
				8	32
					33
					34
					35
				9	36
					37
					38
					39
				10	40
					41
					42
					43
				11	44
					45
					46
					47

地址的高位是页号，低位是页内偏移

逻辑地址=逻辑页号+页面偏移

物理地址=物理页页+物理偏移

优点：利用率高，碎片小，分配及管理简单

缺点：增加了系统开销，可能产生抖动现象

页面淘汰依次规则：访问位=0、修改位=0

页面置换算法：

最优算法：OPT，理想型
随机算法
选进先出，有可能产生抖动
最近最少使用（LRU），局部性原理

段式存储

按用户作业中的自然段来划分逻辑空间，然后调用内存，段的长度可次不一样，段内偏移量不能超过段长

段表
段	段长	基址
0	30K	40K
1	20K	80K
2	15K	120K
3	10K	150K

磁盘管理

读取数据三阶段：

找磁道时间
找块（扇区）时间，旋转延迟时间
传输时间

寻道方法：

先来先服务（FCFS）

最短寻道时间优先（SSTF）

扫描算法（SCAN，电梯算法）

循环扫描（CSCAN）

IO管理

处理顺序：

用户进程
设备无关程序
设备驱动程序
中断处理程序
硬件

位示图

0表示可用，1表示不可用

如果没有说明，默认字从0开始，位从0开始编号

1GB=2^30B

数据库

体系

集中式数据库系统

C/S结构

分布式数据库

并行数据库

数据是集中的

有客户端

ODBC、JDBC

物理上分布，逻辑上集中

物理上分布，逻辑上分布

特点：透明性

共享内存式

无共享内存式

分布式数据库特点：

数据独立性：逻辑独立性、物理独立性，数据独立性（透明）
集中与自治共享结合的控制结构：各局部的DBMS可以独立地管理局部数据库，具有自治的功能。同时，系统又设有集中控制机制，协调各局部的DBMS工作，执行全局应用。
适当增加数据冗余度：在不同的场地存储同一数据的多个副本，可以提高系统的可靠性和可用性，同时也能提高系统性能。
全局的一致性、可串行性和可恢复性

透明性：

分片透明：是指用户不必关心数据是如何分片的，用户对数据的操作在全局关系上进行。
复制透明：用户不用关心数据库在网络中各个节点的复制情况，被复制的数据的更新都由系统自动完成。
位置透明：用户不必知道所操作的数据放在何处，数据分配到哪里或哪些站点存储对用户是透明的。
局部映像透明性（逻辑透明）：是最低层次的透明性，该透明性提供数据到局部到局部数据库的映像，即用户不必关系局部DBMS支持哪种数据模型，使用哪种数据操作语言，数据模型和操纵语言的转换是由系统完成的。

三级模式

模式

外模式：视图级，用户模式

表级：概念模式（CRUD，内模式映射），简称模式

文件级：内模式，操作系统

映射

逻辑独立性：外模式--概念模式映射

物理独立性：概念模式--内模式

仓库

阶段：数据预处理（ETL）--数据仓存储--数据分析--数据展现

OLAP：联机分析。A=analysis

OLTP：数据库，联机事物系统

数据库设计

阶段名称	基本要求	设计依据
需求分析	数据流图数据字典需求说明书
概念结构设计	ER模型
逻辑结构设计	关系模式	转换规则，规范化理论
物理设计		聚簇索引

E-R图

表示实体的关系

实体（矩形）：现实世界中可以区别于其它对象的事件或事物

属性（椭圆）：是实体某方面的特性。可以分为简单属性和复合属性。简单属性，为原子性的，不可以再分割。单值属性，一个实体只有单独的一个值。多值属性，一个属性可能对应一组值。派生属性，可以从其它属性得来。

联系（菱形）：实体内部间或实体间的联系。可以使用1:1，1：*，*：*。表示1对1，1对多，多对多。

矩形+平等线：特殊化的实体

弱实体：一个实体的存在，必须以另一个实体为前提，将这类实现称为弱实体。用嵌套两个矩型来表示。

关系模式

概念

分类

层次模型
网状模型
关系模型
面向对象模型

模型三要素：

数据结构
数据操作
数据的约束条件

目或度：关系模式中属性的个数

候选码（候选键）：唯一标识元组，且无冗余

主键：从候选键里任选一个

主属性与非主属性：组成候选码的就是主属性，其它就是非主属性

外键：其它关系的主键

全码：ALL-KEY,关系模式的所有属性组是这个关系的候选码

关系的3种类型：

基本关系表
查询表
视图表

完整性约束：

实体完整性约束：主键是唯一的，并且非空
参照完整性：外键：要么是其它关系的主键，要么为空
用户自定义完整性约束：vaild data

触发器：可以完成一些复杂的完整性约束

E-R图转关系模式

一个实体必须转换为一个关系模式

联系转换关系模式

一对一联系的转换：

独立的关系模式：并入两端主键及联系自身属性，主键：任一端主键
归并（任意一端）：并入另一端主键及联系自身属性，主键：保持不变

一对多联系的转换：

独立的关系模式：并入两端主键及联系自身属性，主键：多端主键
归并（多端）：并入另一端主键及联系自身性情，主键：保持不变

多对多的联系转换

独立关系模式：并入两端主键及联系自身属性

联系类型	实体	联系独立关系模式	联系归并关系模式	备注
1：1	YES	YES	YES	并入任一端
1：*	YES	YES	YES	并入多端
：	YES	YES	No

关系代数

并交差

属性列：垂直方向的列数，叫目或者度

水平方向：无组行，一个元组叫一个纪录，也是一个实例

所谓并交差，实际上是进行集合的运算。

笛卡尔积： $S_1\times S_2$

结果的属性列数，二者之和

水平方向元组行数，是二者的乘积。

投影： $\pi _{Sno,Sname}(S1)$

表示S1这个表，垂直方向，选择SNO和SNAME两列

选择： $\sigma _{Sno=No003}(S1)$

表示S1这个表，NO=003的这一条纪录

连接： $S1\bowtie S2$

属性列表：二者之和，减去重复列数。

行数，需要进行筛选，同名属性列，取值相等

示例： $\pi_{1,2,3,5}(\sigma_{1=4}(S1\times S2))=S1\bowtie S2$

1、S1、S2取笛卡尔积

2、第1列与第4列取值相等

3、选出1235列

规范化理念

基本概念

设R(U)是属性U上的一个关系模式，X和Y是U的子集。r为R的任一关系，如果对于r中的任意两个元组u,v，只要有u[X]=v[X],就有u[Y]=v[Y],则称X函数决定Y，或称Y函数依赖于X。记为 $X\rightarrow Y$

左侧X：决定因素，右侧Y：被决定因素

依赖分类

部分函数依赖：AB->C,A->C
传递函数依赖：A->B,B->C

规划化理论：Amstrong公理体系

推理：

自反律（Reflexivity）:若 $Y\subseteq X\subseteq U$ ,则 $X\rightarrow Y$
增广律（Augmentation）:若 $Z\subseteq U,X\rightarrow Y$ ,则 $XZ\rightarrow YZ$
传递律（Transitivity）：若， $X\rightarrow Y,Y \rightarrow Z$ ，则 $X\rightarrow Z$

推论：

合并规则：若 $X\rightarrow Y,X\rightarrow Z$ ,则 $X\rightarrow YZ$
伪传递规则：若， $X\rightarrow Y,WY\rightarrow Z$ ，则 $XW\rightarrow Z$
分解规则：由 $X\rightarrow Y,Z\subseteq Y$ , $X\rightarrow Z$

图式法

将关系的函数关系，用“有向图”的方式表示
找出入度为0的属性，并以该属性集合为起点，尝试遍历有向图，若能正常遍历图中所有的结点，则该属性集即为关系模式的候选键
若入度为0的属性集不能遍历图中所有结点，则需要尝试性的将一些中间结点并入入度为0的属性集中，直到该集合能遍历所有结点，集合为候选键。

主属性与非主属性

组成候选码的属性就是主属性，非候选码的就是非主属性

范式判断

存在问题：

数据冗余
修改异常
插入异常
删除异常

第一范式-1NF

在关系模式R中，当且仅当所有域只包含原子值，即每个属性都是不可再分的数据项，则称关系模式R是第一范式

第二范式-2NF

当且仅当关系模式R是第一范式，且每一个非主属性完全依赖候选键（没有不完全依赖）时，则称关系模式R是第二范式

第三范式-3NF

当且仅当关系模式是第二范式，且R中没有非主属性传递依赖于候选键时，则称关系模式R时第三范式。

BC范式（BCNF）

设R是一个关系模式，F是它的依赖集，R属于BCNF当且仅当其F中每个依赖的决定因素必定包含R的某个候选码。

推论：

单属性，至少满足第二范式。
没有非主属性，至少满足第三范式

1NF	属性值都是不可分的原子值
2NF	消除非主属性对候选键的部分依赖
3NF	消除非主属性对候选键的传递依赖
BCNF	消除主属性对候选键的部分依赖和传递依赖

范式	属性不可再分	非主属性部分函数依赖于候选键	非主属性传递函数依赖于候选键	函数依赖左侧决定因素包含候选码
1NF	✓	存在
2NF	✓	不存在	存在
3NF	✓	不存在	不存在	不满足
BCNF	✓	不存在	不存在	满足

模式分解

要点

保持函数依赖分解

冗余函数依赖不需要保留

无损分解:交集决定差集的函数依赖

SQL语言

普通查询

分类	动词	示例
查询	SELECT	$select \,[ \pi]\, from\, [S\times R]\, where\, [\sigma ]$
定义	CREATE、DROP、ALTER
操作	INSERT、UPDATE、DELETE
控制	GRANT、REVORK

分组查询

GROUP BY <列名1> HAVING <条件表达式>

处理类型	处理子类	示例
结果排序	升序或降序	ORDER BY 字段名 DESC\|ASC
集函数	统计	COUNT（DISTINCT）
	求和	SUM
	平均值	AVG
	最大值	MAX
	最小值	MIN
结果分组	将查询结果按列分组	GROUP BY
对分类结果筛选		HAVING

权限控制

GRANT <权限> ON <对象> TO <用户> WITH GRANT OPTION

WITH GRANT OPTION，表示获得权限的用户，还可以将权限赋予其它用户

REVOKE

RESTRICT|CASCADE（级联收回）

并发控制

事务

特性：ACID

A：Atomicity 原子性，要么做，要么不做
C：Consistency 一致性。必须保证是一个一直性状态到另一个一直性状态
I：Isolation:隔离性。一上事物的运行过程中，对其它事物是不可见的。
D：Durability 持续性.一旦事务成功提交，即使数据库奔溃，其对数据的更新操作也永久保存

并发

丢失更新：由于多个事务对同一个数据的修改，导致数据状态不正确。解决方法，加锁。

不可重复读：在一个事务读的过程中，另一个事务对这个数据进行了修改。

读脏数据：A事务在执行过程中，B事务读取了中间态，最后A事务又进行了回滚。

封锁

S封锁

共享锁/S锁/读锁：若事务T对数据对象A加上S锁，其它事务只能对A再加S锁，不能再对A添加X锁。

X封锁

排他锁/独占锁/X锁/写锁：如果一个事务添加了X锁，其它事务不能再添加任意涣。

死锁

算法

查找

顺序查找

时间复杂度：O(n)

二分查找

要求，顺序，有序

时间复杂度： $\log_ 2 n$ ,最多次数 $\log_ 2 n+1$

def binary_search(alist, item):
    first = 0
    last = len(alist) - 1
    while first <= last:
        midpoint = (first + last) // 2
        if alist[midpoint] == item:
            return midpoint
        elif alist[midpoint] > item:
            last = midpoint - 1
        else:
            first = midpoint + 1


testlist = [1, 2, 3, 4]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

散列查找

提取特征值

排序

插入类

直接插入排序

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr


# 测试代码
arr = [7, 6, 5, 4, 3]
print(insertion_sort(arr))

希尔排序

def shell_sort(arr):  
    n = len(arr)  
    gap = n // 2  # 初始间隔  
  
    # 动态定义间隔序列  
    while gap > 0:  
        # 遍历从gap到n-1  
        for i in range(gap, n):  
            # 当前要插入的元素  
            temp = arr[i]  
            # 插入位置的前一个索引  
            j = i  
  
            # 插入排序  
            while j >= gap and arr[j - gap] > temp:  
                # 将元素后移  
                arr[j] = arr[j - gap]  
                # 继续向前查找插入位置  
                j -= gap  
  
            # 找到插入位置，插入元素  
            arr[j] = temp  
  
        # 缩小间隔  
        gap //= 2  
  
    # 返回排序后的数组  
    return arr  
  
# 测试代码  
arr = [12, 34, 54, 2, 3]  
print(shell_sort(arr))

选择类

简单选择

def selection_sort(arr):
    for i in range(len(arr)):
        min_index = i
        for j in range(i + 1, len(arr)):
            if arr[min_index] > arr[j]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr
    # 测试代码


arr = [7, 6, 5, 4, 3]
print(selection_sort(arr))

堆排序

def heapify(arr, n, i):  
    largest = i  # Initialize largest as root  
    left = 2 * i + 1     # left = 2*i + 1  
    right = 2 * i + 2     # right = 2*i + 2  
  
    # See if left child of root exists and is greater than root  
    if left < n and arr[i] < arr[left]:  
        largest = left  
  
    # See if right child of root exists and is greater than root  
    if right < n and arr[largest] < arr[right]:  
        largest = right  
  
    # Change root, if needed  
    if largest != i:  
        arr[i], arr[largest] = arr[largest], arr[i]  # swap  
  
        # Heapify the root.  
        heapify(arr, n, largest)  
  
def heapSort(arr):  
    n = len(arr)  
  
    # Build a maxheap.  
    for i in range(n, -1, -1):  
        heapify(arr, n, i)  
  
    # One by one extract elements  
    for i in range(n-1, 0, -1):  
        arr[i], arr[0] = arr[0], arr[i]   # swap  
        heapify(arr, i, 0)  
  
# 测试代码  
arr = [12, 11, 13, 5, 6, 7]  
heapSort(arr)  
n = len(arr)  
print("Sorted array is")  
for i in range(n):  
    print("%d" %arr[i]),

交换类

冒泡排序

def bubble_sort(arr):  
    n = len(arr)  
    # 遍历所有数组元素  
    for i in range(n):  
        # Last i elements are already in place  
        for j in range(0, n - i - 1):  
            # 遍历数组从0到n-i-1，交换如果元素找到比下一个元素大  
            if arr[j] > arr[j + 1]:  
                arr[j], arr[j + 1] = arr[j + 1], arr[j]  
    return arr  
  
# 测试代码  
arr = [64, 34, 25, 12, 22, 11, 90]  
print(bubble_sort(arr))

快速排序

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)


# 测试代码
arr = [3, 6, 8, 10, 1, 2, 1]
print(quick_sort(arr))

其它排序

归并排序

def merge_sort(arr):  
    if len(arr) <= 1:  
        return arr  
    mid = len(arr) // 2  
    left = merge_sort(arr[:mid])  
    right = merge_sort(arr[mid:])  
    return merge(left, right)  
  
def merge(left, right):  
    merged = []  
    left_index = 0  
    right_index = 0  
  
    # 合并两个有序列表  
    while left_index < len(left) and right_index < len(right):  
        if left[left_index] < right[right_index]:  
            merged.append(left[left_index])  
            left_index += 1  
        else:  
            merged.append(right[right_index])  
            right_index += 1  
  
    # 如果左侧列表还有剩余元素，添加到结果中  
    while left_index < len(left):  
        merged.append(left[left_index])  
        left_index += 1  
  
    # 如果右侧列表还有剩余元素，添加到结果中  
    while right_index < len(right):  
        merged.append(right[right_index])  
        right_index += 1  
  
    return merged  
  
# 测试代码  
arr = [38, 27, 43, 3, 9, 82, 10]  
print("原始数组：", arr)  
sorted_arr = merge_sort(arr)  
print("排序后的数组：", sorted_arr)

基数排序

def counting_sort(arr, digit):  
    size = len(arr)  
    output = [0] * size  
    count = [0] * 10  
  
    # 计算每个数字的出现次数  
    for i in range(size):  
        index = arr[i] // digit  
        count[index % 10] += 1  
  
    # 更新count数组，使得每个值为小于或等于该值的元素的个数  
    for i in range(1, 10):  
        count[i] += count[i - 1]  
  
    # 根据count数组将元素放入输出数组  
    i = size - 1  
    while i >= 0:  
        index = arr[i] // digit  
        output[count[index % 10] - 1] = arr[i]  
        count[index % 10] -= 1  
        i -= 1  
  
    # 将排序好的元素复制回原数组  
    for i in range(size):  
        arr[i] = output[i]  
  
  
def radix_sort(arr):  
    # 获取数组中最大数的位数  
    max_val = max(arr)  
    num_digits = len(str(max_val))  
  
    # 对每一位使用计数排序  
    for digit in range(1, num_digits + 1):  
        counting_sort(arr, 10 ** (digit - 1))  
  
    return arr  
  
  
# 测试代码  
arr = [170, 45, 75, 90, 802, 24, 2, 66]  
print("原始数组：", arr)  
sorted_arr = radix_sort(arr)  
print("排序后的数组：", sorted_arr)

总结

分类	名称	时间复杂度	空间复杂度	最优解	最差解	是否稳定
插入类	直接插入排序	$O(n^2)$	O(1)	$O(n)$	$O(n^2)$	是
插入类	希尔排序	$O(n^{1.3})$	O(1)	$O(n)$	$O(n^2)$	否
选择类	直接选择	$O(n^2)$	O(1)			否
选择类	堆排序	$O(nlog_2n)$	O(1)			否
交换类	冒泡	$O(n^2)$	O(1)			是
交换类	快排	$O(log_2n)$	O(1)		$O(n^2)$	否
其它	归并	$O(log_2n)$	O(n)			是
其它	基数		O(d)			是

特点：

n比较少，用插入、简单选择
基本有序，用插入，冒泡
n比较大，但位数少，用基数排序
n比较大，快排（稳定），堆排序，归并

算法

分治法

特征：把一个问题拆分成多个小规模的相同子问题。一般有递归。

经典问题：斐波那契数列，归并排序，快速排序，矩阵乘法，二分搜索，大整数乘法，汉诺塔

贪心法

局部最优，但整体不见得最优。每步都有明确的既定的策略。

经典问题：背包问题、装箱、多机调度，最小生成树问题（普里姆算法、克鲁斯卡尔算法）

动态规划

用于求最优子结构和递归式

特征：划分子问题，使用数组存储子问题结果，利用查询子问题结果构造最终结果。一般自顶向下时间复杂度为O(2^n),自底向上为O(n^a),效率更高。

经典问题：斐波那契数列，矩阵乘法，背包问题，LCS最长公共子序列

自顶向下：一定有递归

自底向上，一定有数组

回溯

特征：系统地搜索一个问题的所有解或任一解。

经典问题：N皇后问题，迷宫、背包问题

面向对象

基本概念

名称

对象名、属性（状态）、行为(操作)

封装

修饰符

+public

#protected

-private

defalt

类

对象转类，叫抽象化。类转对象，实例化。

组成：类名、数据成员、成员函数

类	对象
类名	对象名
数据成员	属性
成员函数	行为

分类

实体类（数据类）	存在问题，存大量数据
接口类（功能类）	interface,为用户提供交互方式，有大量方法
控制类	描述业务逻辑，在实体和接口之间充当协调者

继承与泛化

父类（超类、泛行）

子类是父类的特殊化，父类是子类的泛化

二义性：java不支持，c++支持

重写（Overriding）：发生在两个类里面，

过载多态（重载）：同一个类里面，有多个方法，名字是一样的。

多态和动态绑定：重写或者重载都是多态的表现形式。

名称	概念	示例
参数多态	应用广泛、最纯的多态	函数传不同的值
包含多态	同样的操作可用于一个类型及其子类型，包含多态一般需要进行运行时的类型检查	一个列表list里，可以添加一个子父类进行
强制多态	编译程序通过语义操作，把操作对象类型强行加以变换，以符合函数或者操作符要求	1+2.0，强制1变成1.0
过载多态	同一个名(操作符、函数)在不同的上下文中代表的含义不同

开发流程

对象分析（需求分析）	对象设计（需求设计）	程序设计（开发）	测试（测试）
认定对象（名词）	识别类及对象	程序设计泛型	算法层
组织对象（抽象成类）	定义属性	选择一种OOPL	类层
对象之间的相互作用	定义服务		模板层
基于对象的操作	识别关系		系统层
	识别包

面积对象设计7大原则

单一职责原则：设计目的单一的类
开放-封闭原则：对扩展开放，对修改封闭
里氏（Liskov）替换：子类可以替换父类
依赖倒置原则：要依赖于抽象，而不是具体实现。针对接口编程，不要针对实现编号程
接口隔离原则：使用多个专门的接口比使用单一的总接口要好
组合重用原则：要尽量使用组合，而不是继承关系达到重用目的
迪米特（Demeter）原则：最少知识法则。一个对象应当对其它对象有尽少可能少的了解

类包原则：

重用发布等价原则：重用的粒度就是发布的粒度
共同封闭原则：包中所有类对于同一性质的变化应该是共同封闭的。一个变化弱对一个包产生影响，则将对该包里的所有类产生影响，而对于其它的包不造成任何影响。
共同重用原则：一个包里所有类应该是共同重用的，如果重用了包里的一个类，那么就要重用包中所有类。
无环依赖原则：在包的依赖关系图中，不允许存在环，包之间的结构必须是一个直接的无环图形。

UML图

简介

分类	名称	概念	特点
结构	类图	一组对象、接口、协作和人们之间的关系	对系统词汇、简单协作、逻辑数据库式建模有帮助
	对象图	一组对象以及它们之间的关系	有冒号就是对象图
	包图	描述类或者其它UML如果组织成包，以及包之间的依赖关系
	组合结构图
	构件图	一个构件之间的组织和依赖，专注于系统的静态关系
	部署图	运行处理结点及构件的配置，给出体系结构的静态实施视图
	制品图
行为	用例图	用例、参与都及他们之间的关系
	顺序图	场景的图像化表示、以时间顺序组织的对象间的交互活动
	通信图	强调收发消息的对象之间的组织关系
	定时图
	状态图	展现了一个状态机，由状态、转换、事件和活动组成
	活动图	专注于系统的动态图，一个活动到另一个活动的流程
	交互概览图

类图：class diagram

类图描述一组对象、接口、协作和它们之间的关系。在OO系统的建模中，最常见的就是类图。类图给出了系统的静态设计视图，活动类图给出了系统的静态进程视图。

名称	线条
关联	实线
依赖	实心虚线
泛化	空心实线
实现	空心虚线
组合	实心菱形
聚合	空心菱形

用例图

简介

当多个用例共同拥有一种类似的结构和行为的时候，可以将他们共性抽象成为父用例，其它的用例作为泛化关系中的子用例。在用例的泛化关系中，子用例是父用例中的一种特殊形式，子用例继承了父用例所有的结构、行为和关系。

关系名称	示例
包含	权限检查--include
扩展	特定情况下才做-extend
泛化	注册（微信注册、手机号注册）

建模流程

识别参与者（必须）
合并需求获得用例（必须）
细化用例描述（必须）
调用用例模型（可选）

对象图：object diagram

对象图描述一组对象及他们之间的关系。对象图描述了在类图中所建立的事物实例的静态快照。和类图一样，这些图给出系统的静态设计视图或静态进程视图，但它们是从真实案例或原型案例角度建立的。

顺序图：sequence diagram

一种交互图，展现了一种交互，它由一组对象或参与者以及它们之间可能发送的消息构成。交互图专注于系统的动态视图。顺序图是强调消息的时间次序交互图。

实线：调用消息。虚线：返回消息

通信图：communication diagram

一种交互图，强制收发消息的对象或参与者的结构组织。顺序图和通信图表达了类似的基本概念，但它们强制的概念不同。

活动图：activity diagram

活动图将进程或其它计算结构展示为计算内部一步步的控制流和数据流。活动图专注于系统动态视图。它对系统的功能建模和业务流程建模特别重要，并强制对象间的控制流程。

状态图：state diagram

描述一个状态机，它由状态、转移、事件和活动组成。状态图给出了对象的动态视图。它对于接口、类或协作的行为建模尤为重要，而且它强调事件导致对象的行为，这非常有助于对反应式系统的建模。

状态图通常有五部分组成：一般状态（起始状态、终止状态）、事件、监护条件、运作、转移（转换）

一个状态图，只能有一个初态，可以没有或者有多个终态

转移是两个状态间的一种关系

当对系统、类或者用例的动态方面建模时，通常是对反应型建模。

格式：事件（参数）-【条件】/动作

事件的常见类型：

信息事件：对象之间发送信号和接收信号，如鼠标
调用事件：一个对象请求调用另一个对象的操作，如方法调用
变换事件：when后面接bool表达式，如when A>100
时间事件：到达某一个时间或经过某一个时间段，用when和after表示

一个状态有以下几个部分：

状态名（name）
进入、退出动作（entry/exit action）
内部转移（internal transition）
子状态（substate）
延迟事件（deferred event）

构建图：component diagram

描述一个封装的类和它的接口、端口以及内部构件和连接件构成的内部结构。构件图用于表示系统的静态设计实现视图。对于由小的部件构建大的系统来说，构件图是很重要的，构件图是类图的变体。

半圆是需接口，整圆是供接口。

部署图：deployment diagram

.描述对运行时处理节点及其生存的构件配置。部署图给出了架构的静态部署视图，通常一个节点包含一个或多个部署图。

设计模式

介绍

结构型：四桥组装外箱带

类类型：公司模姐

创建型

结构型

行为型

类

工厂方法模式

factory method

适配器模式

adapter

模板方法模式

template method

解释器模式

interpreter

对象

抽象工厂模式

abstract factory

桥接模式

bridge

职责链模式

chain of responsibility

备忘录模式

mementto

原型模式

prototype

组合模式

composite

命令模式

command

观察者模式

abserver

单例模式

singleton

装饰器模式

decorator

迭代器模式

iterator

状态模式

state

构建器模式

builder

外观模式

facade

中介模式

mediator

策略模式

strategy

享元模式

flyweight

访问者模式

visitor

代理模式

proxy

详细分类

创建型

名称	说明	关键字
抽象工厂模式 Abstract Factory	提供一个接口，可以创建一系列相关或相互依赖的对象，而无需指定他们具体的类	生产成系列对象
构建器模式 Builder	将一个复杂类的表示与其构造相分离，使得相同的构建过程能够得出不同的表示	复杂对象构造
工厂方法模式 factory method	定义一个创建对象的接口，但由其子类决定需要实例化哪一个类，工厂方法合得子类实例化的过程推迟。	动态生产一个对象
原型模式 Prototype	用原型实例指定创建对象的类型，并且通过拷贝这个原型来创建新的对象	克隆对象
单例模式 Singletom	保证一个类只有一个实例，并提供一个访问它的全局访问点	单实例

结构型

名称

说明

关键字

适配器模式

Adapter

将一个类的接口转换成用户希望的得到的另一种接口。它使原本不相容的接口以相容后协同工作

转换接口

桥接模式

Bridge

将类的抽象部分和它的实现部分分离开来，使它们可以独立地变化。抽象部分通过实现部分的接口与实现部分联系起来。

此时的接口就像一座桥梁一样。

继承树拆分

组合模式

Composite

将有层级关系的多个对象组合成树型结构以表示“整体-部分”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。

Leaf:叶部件，在组合中表示叶节点对象，叶节点没有子节点。定义组合中原有接口对象的行为。

Composite:组合类，定义有子节点的部件行为。在Component接口中实现与子部件相关的操作

Client:客户端应用程序，通过compoent接口控制组合部件的对象。

树型目录结构

装饰模式

Decorator

动态地给一个对象添加一些额外的职责、功能。它提供了用子类扩展功能的一个灵活的替代，比派生一个子类更加灵活。

Component:部件，定义对象的接口，可以给这些对象动态的增加职责（方法）。

Concrete Component:具体部件，定义具体的对象，Decorator可以给它增加额外的职责（方法）。

Decorator:装饰抽象类，维护一个内有的Component,并且定义一个与Component接口一致的接口。

Concreate Decorator:具体装饰对象，给内在的具体部件对象增加具体的职责。

附加职责

外观模式

Facade

为子系统中的一组接口对外提供一个唯一的接口，从而简化了该子系统的使用。

facade:外形类，知道哪些子系统负责处理哪些请求，将客户的请求传递给相应的子系统对象处理。

Subsystem:子系统类，实现子系统的功能，处理由FACADE传过来的任务。子系统不用知道Facade，在任何地方也没有引用Facade。

对外统一接口

享元模式

Flyweight

提供支持大量细粒度对象共享元对象的有效方法。

flyweight:抽象轻量级类，声明一个接口，通过它可以接受外来的状态并作出处理。

ConcreteFlyweight:具体轻量级类，实现Flyweight接口。

UnsharedConcreteFlyweight:不共享的具体轻量级类。

FlyweightFactory:轻量级类工厂，创建并且管理Flyweight对象确保享用flyweight

Client:客户端

文章共享文字对象

代理模式

Proxy

为对象提供一个代理，通过代理访问这个对象。

Proxy:代理维护一个引用使得代理可访问实体，如果relSubject和subject的接口相同，则Proxy会引用subject。

远程代理：负责对请求其期参数编码，向不同的地址空间中实体发送已编码的请求。

虚拟代理：可以缓存实体的其它信息，以便延迟对它的访问。

保护代理：检查调用者的请求是不是有所需的权限。

Subject：抽象实体接口，为RealSubject实体和Proxy代理定义相同的接口，使得RealSubject在任何地方都可以使用Proxy来访问。

Realsubject:真实对象，定义Proxy代理的实体。

快捷方式

行为型

名称	说明	关键字
职责链模式 Chain of Responsibility	为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。 Handler:传递者接口，定义一个处理请求的接口 ConcreteHandleer:具体传递者，处理它所负责的请求。可以访问链中下一个对象，如果可以处理请求就处理它，否则将请求转发给后继者。 Client:客户应用程序，向链中的对象提出最初的请求。
命令模式 Commond	将一个请求（方法调用）封装成一个对象，从而可用不同的请求对客户进行参数化，将请求排队或记录记录请求日志，支持可撤销的操作。 Command:抽象命令类，声明执行操作的一个接口 ConcreteCommon:具体命令类，将一个接收者对象绑定于一个动作，实现Excute方法，以调用接收者的相关操作。 Invoker:调用者，要求一个命令对象执行一个请求 Reciver:接收者，知道如何执行关联请求的相关操作。 Client:客户应用程序，创建一个具体命令类对象，并且设定它的接收者。
解释器模式 Interpreter	给定一种语言，定义它的文法表示，并定义一个解释器，该解释器用来根据文法表示来解释语言中的句子。
迭代器模式 Iterator	提供一种统一的方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象内部的表示。
中介者模式 Mediator	用一个中介对象来封装成一系列的对象交互，它使各对象不需要显示地想到调用，从而达到低耦合，还可以独立地改变对象间的交互。
备忘录模式 Memento	在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。从而可以在以后将该对象恢复到原生保存的状态。
观察者模式 Observer	定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
状态模式 State	允许一个对象在其内部状态改变时改变行为。 Context:情景类，定义客户应用程序有兴趣的接口，维护一个Concrete State（具体状态的子类的实例对象）。 State:抽象状态类，定义一个接口用来封装与Context的一个特别状态（State）相关的行为。 Concrete State:具体状态类，每一个具体状态类（Concrete State）实现了一个Context的状态相关的行为。
策略模式 Strategy	定义一系列算法，把它们一个个封装起来，并且使它们之间可互相替换，从而让算法可以独立于使用它的用户而变化。 Strategy:抽象策略类，定义一个接口给所有支持的算法，Context使用这个接口调用ConcreateStrategy定义算法。 ConcreateStrategy:具体策略类，用ConcreteStrategy对象配置其执行环境。
模板方法模式 Template Method	定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些特定步骤。 AbstractClass:抽象类，定义一个抽象原始的操作，其子类可以重新定义实现一个算法的各个步骤，实现一个模板方法定义一个算法的骨架。些模板方法不仅可以调用原始的操作，还可以调用定义于AbstractClass中的方法或者其它对象中的方法。 ConcreteClass:具体子类，实现原始的操作以完成子类特定算法的步骤。
访问者模式 Visitor	一个作用于某对象结构中的各元素的操作，使得在不改变元素的类的前提下定义作用于这些元素的新操作。 Visitor:抽象访问者，为对象结构类中的每一个ConcreteElement的类声明一个Visit操作。 ConcreteVisitor:具体访问者，实现每个由Visitor声明的操作。 Element:元素，定义一个Accept操作，它以一个访问者为参数。 ConcreteElement:抽象具体元素，实现Accept操作，该操作公一个访问者为参数。 ObjectStructure:对象结构体。

信息安全

基础知识

五要素：

机密性：确保信息不暴露给未授权的实体或进程
完整性：只有得到允许的人才能修改数据，并且能够判断出数据是否已经被篡改
可用性：得到授权的实体在需要时可访问数据，即攻击者不能占用所有的资源而阻碍授权者的工作。
可控性：可以控制授权范围内的信息流向及行为方式。
可审查性：对出现的信息安全问题提供调查的依据和手段。

加密与认证

加密技术

对称加密：两方用到的密钥是一样的（非公开秘钥）

特点：加密强度不高，但效率高。密钥分发困难。

常见算法：3S+5I

DES、AES、3DES、RC5、IDEA

非对称加密：两方用的密钥不一样。

加密速度慢，但强度不高。

常见算法：AACC

RSA、DSA、ECC

数字签名

作用：

接收者可验证消息来源的真实性
发送者无法否认发送过该消息
接收者无法伪造或篡改消息

摘要应用

概念：由单向散列函数加密成固定长度的散列值。

常见方法：MD5（128位）、SHA（160位）

数字证书

确认身份：数字证书

确认消息：数字签名

安全协议

PGP	HTTPS	SSL	应用层
			表示层
			会话层
TLS	SET		传输层
防火墙	IPSec		网络层
链路加密	PPIP	L2TP	数据链路层
隔离		屏蔽	物理层

PGP：优良保密协议，针对邮件和文件混合加密系统。

SSL：安全套接字协议，工作在应用层到传输层。

TLS(Transport Layer Security):传输层安全协议。

SET：secure Electronic Transaction:安全电子交易协议，用于商务和身份认证。

IPSEC（Internet Protocol Security）：互联网安全协议，对IP包加密。

安全威胁

网络攻击

被动攻击：监听，非法登录。消息内容获取和业务流分析

主动攻击：中断（可用性）、篡改（完整性）、伪造（真实性）

计算机病毒

病毒：一般会破坏数据，木马，用于制作，后门程序。

类型	感染目标
引导型病毒	引导盘
文件型病毒	exe文件
宏病毒	doc xls 等office文件
网络型病毒	电子邮件
混合型

安全控制

网络安全控制技术

存储安全：

信息使用的安全
系统安全监控
计算机病毒防治
数据加密
防治非法攻击

用户识别技术：

口令认证
生物识别认证
U盾认证
多因子认证

访问控制技术与列表

控制：控制不同用户对信息资源的访问权限
ACL：一种基于包过滤的访问控制技术，它可以根据设定的条件对接口上的数据包进行过滤，允许其通过或丢弃。访问控制列表被广泛地应用于路由器和三层交换机，借助于访问控制列表，可以有效地控制用户对网络的访问，从而最大程序地保障网络安全。ACL也可以结合防火墙使用。

防火墙技术

建立在内外网边界上的，它认为内部网络是安全和可信的，外部网络是不安全和不可信的。

作用：

访问控制功能（ACL）
内容控制
全面的日志功能
集中管理功能
自身的安全和可用性
流量控制
网络地址转换（NAT）
VPN

分类：

网络级：包过滤、状态检测
应用级：双鹤主机、屏蔽主机、屏蔽子网

入侵检测与防御

网络中的部署位置

入侵的响应能力

IDS

入侵检测

IDS一般是采用旁路挂接的方式

IDS设备对于网络中的入侵行为往往是采用将入侵行为计入日志，并向网络管理员发出报警。

IPS

入侵防御

IPS一般是作为一种网络设备串接在网络中

检测到入侵行为后，能够对攻击行为进行主动防御，例如丢弃连接的数据包以阻断攻击会话。

数据流图

需求的任务和需求的过程：

问题识别，定位当前问题
分析与综合，确定大致解决方案、功能方案
编制需求分析文档，把功能方案记下来
需求分析与评审，确保功能方案的可行性

结构化分析的结果：一套分层的数据流图、一本数据词典、一组小说明，补充材料

顶层图--0层图。数据流图建模遵循：自顶向下，从抽象到具体的原则。

元素	说明	图元
数据流	由一组固定的成分的数据组成，表示数据的流向。每个数据流通常有一个合适的名词，反映数据流的含义。数据流必须和加工相关，即从加工流向加工、数据流向加工加工或加工流向向数据源。	$\rightarrow$
加工	加工描述了输入数据流到输出数据流之间的变换，也就是输入数据流做了什么处理后变成了输出数据流。	$\bigcirc \square$
数据存储（文件）	用来表示暂时存储的数据，每个文件都有名字。流向文件的数据流表示写文件，流出的表示读文件。
外部实体	指存在软件系统外的人员、组组或外部第三方系统。

数据字典包含：

数据流条目：数据流条目给出了DFD中数据流的定义，通常列出该数据流的各组成数据项。
数据存储条目：对数据存储的定义。
数据项条目：不可再分的数据单位
基本加工条件：加工条目是用来说明DFD中基本加工的处理逻辑的，由于下层的基本加工是由上层的加工分解而来，只要有了基本的加工说明，就可以理解其它加工。

平衡

父子平衡

父图与子图之间平衡是指任何一个DFD子图边界上的输入/输出数据流必须与其父图对应加工的输入/输出数据流保持一致。
如果父图中某个加工的一条数据流对应于子图中的几条数据流，而子图中组成这些数据流的数据项全体正好等于你图中的这第数据流，那么它们仍然是平衡的。

子内平衡

黑洞：只有输入没有输出

奇迹：只有输出没有输入

灰洞：加工中输入不足以产生输出

结构化描述

概念

结构化语言是一种介于自然语言和形式化语言之间的半形式化语言，是自然语言的一个受限子集。

外层

用来描述控制结构、采用顺序、选择和重复3种基本结构。

顺序结构：一组祈始语句、选择语句’重复语句的顺序排列。
选择结构：一般用IF-THEN-ELSE-ENDIF、CASE-OF-ENDCASE等关键字
重复结构：DO-WHILE-ENDDO、REPEAT-UNTIL等关键词。

内层

一般采用祈使语句的自然语言短语，使用数据字典中的名词和游戏的自定义词，其动词含义要具体，尽量不用形容词和副词来修饰，还可使用一些简单的算法运算和逻辑运算符号。

判定表

某些情况下，数据流图中某个加工的一组运作依赖于多个逻辑条件的取值，此时用判定表能够清楚地表示复杂的条件组合与应做的运作之间的关系。

判定表由4个部分组成，双双线分割成下面4个区域。

条件定义	条件取值的组合
运作定义	在各种取值组合下应执行的动作

判定树

判定树是判定表的变形，一般情况下比判定表更直观，且易于理解和使用。

termandy

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
软件设计学习笔记

分类名称概念特点结构类图一组对象、接口、协作和人们之间的关系对系统词汇、简单协作、逻辑数据库式建模有帮助对象图一组对象以及它们之间的关系有冒号就是对象图包图描述类或者其它UML如果组织成包，以及包之间的依赖关系组合结构图构件图一个构件之间的组织和依赖，专注于系统的静态关系部署图运行处理结点及构件的配置，给出体系结构的静态实施视图制品图行为用例图用例、参与都及他们之间的关系顺序图场景的图像化表示、以时间顺序组织的对象间的交互活动通信图。
复制链接

扫一扫