TACGIB CLUB

云影时空

0%

软件设计师考试备考笔记

发表于 阅读次数： Valine：

这次软考准备匆忙，临时抱佛脚，整理此份临考笔记，希望有用。

1. McCabe度量法计算环路复杂度

解法有三：

  • 流程图中的区域数等于环形复杂度；
  • 流程图G的环形复杂度V(G)=E-N+2，其中E是流图中边的条数，N是节点数；
  • 流图G的环形复杂度V(G)=P+1，其中P是流程图中判定节点的数目

2. 测试用例覆盖

语句、条件、判定/条件、路径

逻辑覆盖率：语句覆盖<条件覆盖<判定覆盖<条件-判定覆盖<组合覆盖<路径覆盖

语句覆盖：设计用例，使程序中的每个可执行语句至少执行一次。
条件覆盖：设计用例，使每个判断中的每个条件的可能取值至少满足一次。
判定覆盖：设计用例，使得程序中的每一个判断的取真分支和取假分支至少经历一次。
条件/判定覆盖：设计用例，使判定条件中的所有可能（条件成立、不成立）至少执行一次取值，同时，所有判断的可能结果（取真，取假），至少执行一次。
组合覆盖：设计用例，使所有可能的条件取值组合至少执行一次。
路径覆盖：设计测试用例，来覆盖程序中的所有可能执行的路径。

3. 依赖、泛化、关联、聚合、组合

UML中有4种关系：依赖、关联、泛化和实现

依赖：两个事物减额的语义关系，其中一个事物发生变化会影响另一个事物的语义，是单向的，依赖关系用虚线加箭头表示

依赖关系

关联：是一种结构关联，描述了一组链，是对象之间的连接，聚合(聚集) 和 组合是特殊类型的关联。在连接线的端点可以表示重复度（*表示多）

关联、聚集、组合

泛化：泛化是一种特殊/一般的关系，特殊元素（子元素）的对象可替代一般元素（父元素），子元素共享了父元素的结构和行为，用带有一个空心箭头的实线表示，箭头指向父元素。

泛化

实现：实现是类元之间的语义关系，其中一个类元指向另一个类元保证执行的契约。一种是在接口和实现他们的类或构件之间；另一种是在用例和实现他们的协作之间，用带有空心箭头的虚线表示。

实现

4. 动态绑定、静态绑定

绑定：就是一个方法的调用与调用这个方法的类连接在一起的过程被称为绑定。

静态绑定，也叫前期绑定、编译时绑定
动态绑定，也叫后期绑定、运行时绑定

5. UML活动图、状态图、顺序图、类图

调用—–→
返回- - - →

类图：展现了一组对象、接口、协作和他们之间的关系。类图包含：

  • 类；
  • 接口；
  • 协作；
  • 依赖、泛化和关联关系。

下列情况使用类图：

  • 对系统的词汇建模；
  • 对简单的协作建模；
  • 对逻辑数据库模式建模。

对象图：展现了某一时刻一组对象以及他们之间的关系，描述了在类图中所建立的事务的实例的静态快照。对象图包括：

  • 对象；
  • 链。

多用于静态数据结构建模。

用例图：展现了一组用例、参与者以及他们之间的关系。

  • 用例图包括：
  • 用例；
  • 参与者；
  • 用例之间的扩展关系和包含关系，参与者和用例之间的关联关系，用例与用例以及参与者与参与者之间的泛化关系。

可在下列两种方式使用用例图：

  • 对系统的语境建模；
  • 对系统的需求建模。

交互图：用于对系统的动态方面进行建模。一般包括：

  • 对象；
  • 链；
  • 消息。

序列图、通信图、交互概览图、计时图

状态图：展示了一个状态机，由状态、转换、事件和活动组成，状态分为简单状态和组合状态。

状态图关注系统的动态试图，对于接口、类和写作的行为建模尤为重要，强调对象行为的事件顺序。

活动图：一种特殊的状态图，它揭晓了在系统内从一个活动到另一个活动的流程。活动图专注于系统的动态试图，他对于系统的功能建模特别重要，并强调对象间的控制流程。

活动图一般包括：活动状态和动作状态、转换、对象。

通常有以下两种使用活动图的情况：

  • 对工作流建模；
  • 对操作建模。此时将活动图当做流程图使用。

构件图：展现了一些构件之间的组织和依赖。构件图专注于系统的静态实现视图。通常把构建映射为一个或多个类、接口或写作。

组合结构图：用于描述一个分类器（如类、构建或用例）的内部结构，分类器与系统中其他组成部分之间的交互接口，展示一组相互协作的实例如何完成特定的任务，描述设计、架构模式或策略。

部署图：对面向对象系统的物理方面建模的方法，展现了运行时处理结点及其中间件（制品）的配置。部署图对系统的静态部署视图进行建模，他与构件图相关。通常，一个结点是一个运行时存在并代表一项计算资源的物理元素，至少拥有一些内容，常常具有处理能力，包含一个或多个构件。

包图：用于把模型本身组织或层次结构的通用机制，不能执行，展现由模型本身分解而成的组织单元以及其间的依赖关系。

一个元素只能被一个包所拥有，拥有关系的包形成了一个命名空间，其中同一种元素的名称必须唯一。

6. 创建型模式、行为模式

原文链接

6.1 创建型模式

创建型模式提供了创建对象的机制， 能够提升已有代码的灵活性和可复用性。

工厂方法Factory Method
在父类中提供一个创建对象的接口以允许子类决定实例化对象的类型。

抽象工厂Abstract Factory
让你能创建一系列相关的对象， 而无需指定其具体类。

生成器Builder
使你能够分步骤创建复杂对象。 该模式允许你使用相同的创建代码生成不同类型和形式的对象。

原型Prototype
让你能够复制已有对象， 而又无需使代码依赖它们所属的类。

单例Singleton
让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

6.2 行为模式

行为模式负责对象间的高效沟通和职责委派。

责任链Chain of Responsibility
允许你将请求沿着处理者链进行发送。 收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

命令Command
它可将请求转换为一个包含与请求相关的所有信息的独立对象。 该转换让你能根据不同的请求将方法参数化、 延迟请求执行或将其放入队列中， 且能实现可撤销操作。

迭代器Iterator
让你能在不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素。

中介者Mediator
能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。

备忘录Memento
允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态。

观察者Observer
允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象。

状态State
让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。

策略Strategy
能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。

模板方法Template Method
在超类中定义一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。

访问者Visitor
将算法与其所作用的对象隔离开来。

7. 适配器模式、装饰器模式

结构型模式介绍如何将对象和类组装成较大的结构， 并同时保持结构的灵活和高效。

适配器Adapter
让接口不兼容的对象能够相互合作。

桥接Bridge
可将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构， 从而能在开发时分别使用。

组合Composite
你可以使用它将对象组合成树状结构， 并且能像使用独立对象一样使用它们。

装饰Decorator
允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。

外观Facade
能为程序库、 框架或其他复杂类提供一个简单的接口。

享元Flyweight
摒弃了在每个对象中保存所有数据的方式， 通过共享多个对象所共有的相同状态， 让你能在有限的内存容量中载入更多对象。

代理Proxy
让你能够提供对象的替代品或其占位符。 代理控制着对于原对象的访问， 并允许在将请求提交给对象前后进行一些处理。

8. 上下文无关文法

只要文法的定义里有某个产生式，不管一个非终结符前后的串是什么，就可以应用相应的产生式进行推导。

9. a=0, c=b/a, 编译时不报错，执行时异常

10. 数据库，先写入日志，再写入数据文件，故障时恢复

11. 查员工数大于2的部门的平均工资

select 部门, avg(应发工资) as 平均工资 from 工资表 group by 部门 having count(姓名) > 2;

12. 事务原子性、一致性、隔离性和持久性

事务是指对系统进行的一组操作，为了保证系统的完整性，事务需要具有ACID特性，具体如下：

原子性（Atomic）

一个事务包含多个操作，这些操作要么全部执行，要么全都不执行。实现事务的原子性，要支持回滚操作，在某个操作失败后，回滚到事务执行之前的状态。

回滚实际上是一个比较高层抽象的概念，大多数DB在实现事务时，是在事务操作的数据快照上进行的（比如，MVCC），并不修改实际的数据，如果有错并不会提交，所以很自然的支持回滚。

而在其他支持简单事务的系统中，不会在快照上更新，而直接操作实际数据。可以先预演一边所有要执行的操作，如果失败则这些操作不会被执行，通过这种方式很简单的实现了原子性。

一致性（Consistency）

一致性是指事务使得系统从一个一致的状态转换到另一个一致状态。事务的一致性决定了一个系统设计和实现的复杂度。事务可以不同程度的一致性：

  • 强一致性：读操作可以立即读到提交的更新操作。
  • 弱一致性：提交的更新操作，不一定立即会被读操作读到，此种情况会存在一个不一致窗口，指的是读操作可以读到最新值的一段时间。
  • 最终一致性：是弱一致性的特例。事务更新一份数据，最终一致性保证在没有其他事务更新同样的值的话，最终所有的事务都会读到之前事务更新的最新值。如果没有错误发生，不一致窗口的大小依赖于：通信延迟，系统负载等。

其他一致性变体还有：

  • 单调一致性：如果一个进程已经读到一个值，那么后续不会读到更早的值。
  • 会话一致性：保证客户端和服务器交互的会话过程中，读操作可以读到更新操作后的最新值。

隔离性（Isolation）

并发事务之间互相影响的程度，比如一个事务会不会读取到另一个未提交的事务修改的数据。在事务并发操作时，可能出现的问题有：

  • 脏读：事务A修改了一个数据，但未提交，事务B读到了事务A未提交的更新结果，如果事务A提交失败，事务B读到的就是脏数据。
  • 不可重复读：在同一个事务中，对于同一份数据读取到的结果不一致。比如，事务B在事务A提交前读到的结果，和提交后读到的结果可能不同。 不可重复读出现的原因就是事务并发修改记录，要避免这种情况，最简单的方法就是对要修改的记录加锁，这回导致锁竞争加剧，影响性能。另一种方法是通过MVCC可以在无锁的情况下，避免不可重复读。
  • 幻读：在同一个事务中，同一个查询多次返回的结果不一致。事务A新增了一条记录，事务B在事务A提交前后各执行了一次查询操作，发现后一次比前一次多了一条记录。 幻读是由于并发事务增加记录导致的，这个不能像不可重复读通过记录加锁解决，因为对于新增的记录根本无法加锁。需要将事务串行化，才能避免幻读。

事务的隔离级别从低到高有：

  • Read Uncommitted：最低的隔离级别，什么都不需要做，一个事务可以读到另一个事务未提交的结果。所有的并发事务问题都会发生。
  • Read Committed：只有在事务提交后，其更新结果才会被其他事务看见。 可以解决脏读问题。
  • Repeated Read：在一个事务中，对于同一份数据的读取结果总是相同的，无论是否有其他事务对这份数据进行操作，以及这个事务是否提交。 可以解决脏读、不可重复读。
  • Serialization：事务串行化执行，隔离级别最高，牺牲了系统的并发性。 可以解决并发事务的所有问题。

通常，在工程实践中，为了性能的考虑会对隔离性进行折中。

持久性（Durability）

事务提交后，对系统的影响是永久的。

13.时间复杂度计算

时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。

Ο(1) ＜ Ο(log2n) ＜ Ο(n) ＜ Ο(nlog2n) ＜ Ο(n²) ＜ Ο(n³) ＜…＜ Ο(2^n) ＜ Ο(n!) < O(n^n)

对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个循环的时间复杂度为 O(n*m)。

对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c…，则这个循环的时间复杂度为 O(n*a*b*c…)。

对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。

对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。

T(n) = T(n-1) + n
=T(n-1) + n
=T(n-2)+(n-1) + n
=T(n-3)+(n-2)+(n-1) + n
…
=T(0)+1+2+…+(n-2)+(n-1) + n
=1+1+2+…+(n-2)+(n-1) + n
=1+(n+1)*n/2

所以为 O(n²)

14. Prim、Kruskal算法

一开始，将初始点作为生成树团块的唯一成员，然后，从团块通向团块外（团块中没有的点）的边中选择一条最短的，并将其通向的点加入生成树团块，重复这一过程，直至生成树团块包含了整个图。

Prim

“加边”：图有n个点，将图中所有边取出按边权排序，这时图中只有点，没有边，然后从最小的开始再放回图中，放入后不成环就可以留下，不然就拿走，就这样一直放，直到放进去了n-1条边，结束。此时，图中会形成一棵树，便是最小生成树，其总路径就是放进去留下的边的边权之和。

Kruskal

15. DFD数据流

数据流图（DFD）：用处理、外部实体、数据流以及数据存储来表示系统需求的图表

DFD的特点：

  • 图形元素少且符号简单易懂
  • 较充分表达系统的主要需求：输入、输出、处理和数据存储
  • 最终用户、管理人员和系统开发人员只需稍加培训即可读懂DFD图，方便交流

数据流图1

数据流图2

16. 数据库设计 实体联系图

点击前往原文链接
实体关系图（Entity Relation Diagram，ERD），用于数据库设计的结构图，描述系统内的实体以及实体之间的关系。

ER图包含实体、属性和关系。

实体是一个系统内可定义的事物或概念，对应数据库中的表，如人/角色（例如学生），对象（例如发票），概念（例如简介）或事件（例如交易）。在 ER 模型中，实体用矩形表示，其名称位于上方，其属性列在实体形状的主体中。

属性也称为列、字段。一个属性包括属性名、类型以及长度、是否可为空，以及主键、外键等标识。

主键（Primary Key，PK），是一种特殊的实体属性，用于界定数据库表中的记录的独特性，一个表只能拥有一个主键。

外键（Foreign Key，FK），是对主键的引用，用于识别实体之间的关系。一个表的外键可以有多个，且多个记录可以共享相同的外键值。下面的 ERD 示例展示了实体中的外键引用另一个实体。

关系，两个实体之间的关系包括1对1,1对多和多对多。

1对1：主要用于将实体分成两部分，简洁地将资讯呈现，使读者更容易理解。

1对1关系

1对多：X 的一个实例可以链接到Y的许多实例，而 Y 的一个实例仅链接到 X 的一个实例。

一对多关系

多对多：在设计数据库时，多对多关系通过一个操作的实体被分成两个一对多的关系，如下图学生与课程之间是多对多关系，通过增加一个“选课”操作实体，转变为两个一对多关系。

示例：

多对多关系

电影租赁系统

贷款系统

在线商店

17. 协作图（通信图）

通信图的概念：通信图（协作图）是表现对象交互关系的图，它展现了多个对象在协同工作达成共同目标的过程中互相通信的情况，通过对象和对象之间的链、发送的消息来显示参与交互的对象。

是一种交互图，它描述的是对象和对象之间的关系，即一个类操作的实现。简而言之就是，对象和对象之间的调用关系，体现的是一种组织关系。

18. 策略模式、观察者模式

策略模式是一种行为设计模式， 它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。

当你想使用对象中各种不同的算法变体， 并希望能在运行时切换算法时， 可使用策略模式。

访问者模式是一种行为设计模式， 它能将算法与其所作用的对象隔离开来。

如果你需要对一个复杂对象结构 （例如对象树） 中的所有元素执行某些操作， 可使用访问者模式。

19. 归并排序、插入排序

归并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// 归并排序（C-迭代版）
int min(int x, int y) {
    return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
    int* a = arr;
    int* b = (int*) malloc(len * sizeof(int));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg + seg) {
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        int* temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

// 归并排序（C-递归版）
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
}

归并排序

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

插入排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 插入排序
void InsertSort(int arr[], int len){
    // 检查数据合法性
    if(arr == NULL || len <= 0){
        return;
    }
    for(int i = 1; i < len; i++){
        int tmp = arr[i];
        int j;
        for(j = i-1; j >= 0; j--){
            //如果比tmp大把值往后移动一位
            if(arr[j] > tmp){
               arr[j+1] = arr[j];
            }
            else{
               break;
            }
        }
        arr[j+1] = tmp;
    }
}

20. 算法复杂度

时间、空间

21. 数值表示

22. 程序计数器

程序计数器是用于存放下一条指令所在单元的地址的地方。

23. 可靠度计算

串联：R = R1*R2…Rn

并联：R = 1 - (1-R1)*(1-R2)…(1-Rn)

串联+并联都有：把并联的看作一个整体，再用串联的方法

24. 外部实体

外部实体（External Entities）又称外部项，是指独立于系统而存在的，但又和系统有联系的实体，它表示数据的外部来源和最后去向。 例如顾客、仓库、查询者等。

25. PV操作

P(x)：检查上一个进程是否完成
V(x)：唤醒当前进程指向下一个进程

26. 算法设计策略

贪心、动态规划

将原问题分解成若干个子问题。与分治法不同的是，其分解出的子问题往往不是相互独立的。这种情况下若用分治法会对一些子问题进行多次求解，这显然是不必要的。动态规划法在求解过程中把所有已解决的子问题的答案保存起来，从而避免对子问题重复求解。

贪心法总是做出在当前看来最好的选择，也就是说贪心法并不从整体最优考虑，它所做出的选择只是在某种意义上的局部最优选择。虽然贪心法并不能对所有问题都得到整体最优解，但是对许多问题它能产生整体最优解。有些情况下，贪心法虽然不能得到整体最优解，但其最终结果却是最优解的很好的近似。

27. 二叉排序树遍历

前序；先访问根节点，然后从左到右遍历根节点的各棵子树
后序：先从左到右遍历根节点的各棵子树，然后访问根节点
层序：先访问处于1层上的节点，然后从左到右以此访问处于2层上的节点，以此类推，自上而下，自左至右逐层访问树各层上的节点

28. 矩阵顶点、有向图、无向图、广度优先遍历序列

29. 关系代数表达式

关系代数中包括了：并、交、差、乘、选择、投影、联接、除、自然联接等操作。

五个基本操作：并(∪)、差(-)、笛卡尔积(×)、投影(π)、选择(σ)

四个组合操作：交(∩)、联接(等值联接)、自然联接(RcrossS)、除法(÷)

30. 关系模式

31. 不确定有限自动机（NFA）状态转换图

什么是NFA(不确定的有穷自动机)和DFA(确定的有穷自动机)

32. 类图、组件图、通信图、部署图

33. 过载多态

34. 存储空间题目

内存按字节编址，若用存储容量为32K * 8bit的存储器芯片构成地址从A0000H到DFFFFH的内存，则至少需要多少芯片？

因为，DFFFFH-AFFFFH=3FFFFH ≈ 40000H = 2^18B
又因为，32K = 32 * 2^10
所以，2^18 / (32 * 2^10) = 2^8 / 32 = 8

35. 文件索引题目

文件系统采用多级索引结构，磁盘块大小为1K字节，每块3字节，二级索引时最大文件长度为：(1024 / 3) = 341^2，一级为：1024 /3 = 341

36. 极限编程的12个最佳实践

（1）计划游戏 ( Planning Game )

快速制定计划、随着细节的不断变化而完善；

详解：要求结合项目进展和技术情况，确定下一阶段要开发与发布的系统范围。当计划赶不上实际变化时就应更新计划。

（2）小型发布 ( Small Release )

系统的设计要能够尽可能早地交付；

详解：强调在非常短的周期内以递增的方式发布新版本，从而可以很容易地估计每个迭代周期的进度，便于控制工作量和风险；同时，也可以及时处理用户的反馈。

（3）系统隐喻( System Metaphor )

找到合适的比喻传达信息；

详解：通过隐喻来描述系统如何运作、新的功能以何种方式加入到系统。它通常包含了一些可以参照和比较的类和设计模式。

（4）简单设计( Simple Design )

只处理当前的需求使设计保持简单；

详解：任何时候都应当将系统设计的尽可能简单。不必要的复杂性一旦被发现就马上去掉。

（5）测试驱动( Test-driven )

先写测试代码再编写程序；

详解：程序员不断地编写单元测试，在这些测试能够准确无误地运行的情况下开发才可以继续。

（6）重构( Refactoring )

重新审视需求和设计，重新明确地描述它们，以符合新的和现有的需求；

详解：代码重构是指在不改变系统行为的前提下，重新调整、优化系统的内部结构以减少复杂性、消除冗余、增加灵活性和提高性能。

（7）结对编程( Pair Programming )

由两个程序员在同一台电脑上共同编写解决同一问题的代码。

详解：通常一个人负责写编码，而另一个负责保证代码的正确性与可读性。

（8）集体所有权（Collective Ownership）

任何人在任何时候都可以在系统中的任何位置更改任何代码。

详解：每个成员都有更改代码的权利，所有的人对于全部代码负责。

（9）持续集成( Continuous Integration )

可以按日甚至按小时为客户提供可运行的版本；

提倡在一天中集成系统多次，而且随着需求的改变，要不断的进行回归测试，避免了一次系统集成的恶梦。

（10）每周工作40小时 ( 40-hour Week )

要求项目团队人员每周工作时间不能超过40小时，加班不得连续超过两周，否则反而会影响生产率。

（11）现场客户( On-site Customer )

在团队中加入一位真正的、起作用的用户，他将全职负责回答问题。

详解：要求至少有一名实际的客户代表在整个项目开发周期在现场负责确定需求、回答团队问题以及编写功能验收测试。

（12）编码标准( Code Standards )

强调通过指定严格的代码规范来进行沟通，尽可能减少不必要的文档。

37. 管道过滤器不支持批处理和并发控制

38. 名词短语、动词短语

名词短语暗示类及其属性；
动词短语暗示其职责或操作。

39. 三级结构 | 两级映像的数据库体系结构

用户模式、外模式、内模式、模式、内模式

40. 插入、快速、归并、堆排序的时间复杂度

排序算法复杂度

41.无向图

任意两个顶点之间存在路径
任意顶点出发可遍历图中所有顶点
邻接矩阵是对称矩阵

42. 哈夫曼树（最优二叉树）

对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法：

  • 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；
  • 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
  • 重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。

43. JDBC

JDBC 指 Java 数据库连接，是一种标准Java应用编程接口（ JAVA API），用来连接 Java 编程语言和广泛的数据库。

从根本上来说，JDBC 是一种规范，它提供了一套完整的接口，允许便携式访问到底层数据库，因此可以用 Java 编写不同类型的可执行文件，

文章使用小书匠MarkDown编辑器书写，大家可以通过本站小书匠邀请码一文获取邀请码及下载链接。

秋风木叶
2021-5-22
有您的赞赏，我会更加有动力！