数据库表结构设计参考(第三版)

数据库表结构设计数据库表结构设计是数据库设计的重要环节之一。

一个好的数据库表结构设计可以提高数据存储和查询效率，保证数据的准确性和一致性，同时也方便扩展和维护数据库系统。

在进行数据库表结构设计之前，需要明确数据库系统的需求和目标。

对于不同的应用场景和业务需求，数据库表结构设计可能会有所不同。

下面将以一个电商网站为例，介绍如何进行数据库表结构设计。

一、需求分析在电商网站中，我们需要存储商品、用户、订单等相关信息。

首先，我们需要明确需要存储哪些信息，这些信息之间是否存在关联关系。

例如，商品和订单之间存在关联关系，订单和用户之间也存在关联关系。

其次，我们需要确定每个信息对象的属性，即每个表中的字段。

二、实体-关系图设计根据需求分析的结果，我们可以根据实体-关系模型进行数据库表结构设计。

在这个电商网站中，我们可以根据实体-关系图设计出商品表、用户表和订单表三个基本表。

1. 商品表商品表用于存储商品的相关信息，可以包括商品ID、名称、描述、价格、库存等字段。

其中，商品ID作为主键，可以用于唯一标识每个商品。

另外，可以根据实际需求添加其他字段，如商品分类、销量等。

2. 用户表用户表用于存储用户的相关信息，可以包括用户ID、用户名、密码、手机号、邮箱等字段。

其中，用户ID作为主键，可以用于唯一标识每个用户。

另外，可以根据实际需求添加其他字段，如用户等级、积分等。

3. 订单表订单表用于存储订单的相关信息，可以包括订单ID、用户ID、商品ID、数量、金额、下单时间等字段。

其中，订单ID作为主键，可以用于唯一标识每个订单。

用户ID和商品ID可以作为外键，用于关联用户表和商品表。

另外，可以根据实际需求添加其他字段，如订单状态、收货地址等。

三、表关系设计在实体-关系图设计的基础上，我们需要确定表之间的关系。

在这个电商网站中，商品和订单之间存在一对多的关系，即一个订单可以包含多个商品；订单和用户之间也存在一对多的关系，即一个用户可以有多个订单。

数据库表结构设计参考数据库表结构设计参考表名外部单位表（DeptOut）列名数据类型（精度范围）空/非空约束条件外部单位ID 变长字符串(50) N 主键类型变长字符串(50) N单位名称变长字符串(255) N单位简称变长字符串(50)单位全称变长字符串(255)交换类型变长字符串(50) N 交换、市机、直送、邮局单位邮编变长字符串(6)单位标识(英文) 变长字符串(50)排序号整型(4)交换号变长字符串(50)单位领导变长字符串(50)单位电话变长字符串(50)所属城市变长字符串(50)单位地址变长字符串(255)备注变长字符串(255)补充说明该表记录数约3000条左右，一般不做修改。

初始化记录。

表名外部单位子表（DeptOutSub）列名数据类型（精度范围）空/非空约束条件外部子单位ID 变长字符串(50) N父ID 变长字符串(50) N 外键单位名称变长字符串(255) N单位编码变长字符串(50)补充说明该表记录数一般很少表名内部单位表（DeptIn）列名数据类型（精度范围）空/非空约束条件内部单位ID 变长字符串(50) N 主键类型变长字符串(50) N单位名称变长字符串(255) N单位简称变长字符串(50)单位全称变长字符串(255)工作职责排序号整型(4)单位领导变长字符串(50)单位电话（分机）变长字符串(50)备注变长字符串(255)补充说明该表记录数较小（100条以内），一般不做修改。

维护一次后很少修改表名内部单位子表（DeptInSub）列名数据类型（精度范围）空/非空约束条件内部子单位ID 变长字符串(50) N父ID 变长字符串(50) N 外键单位名称变长字符串(255) N单位编码变长字符串(50)单位类型变长字符串(50) 领导、部门排序号Int补充说明该表记录数一般很少表名省、直辖市表（Province）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N 名称变长字符串(50) N 外键投递号变长字符串(255) N补充说明该表记录数固定表名急件电话语音记录表（TelCall）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N 发送部门变长字符串(50) N接收部门变长字符串(50) N拨打电话号码变长字符串(50)拨打内容变长字符串(50)呼叫次数Int呼叫时间Datetime补充说明该表对应功能不完善，最后考虑此表表名摄像头图像记录表（ScreenShot）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N 拍照时间Datetime N取件人所属部门变长字符串(50) N取件人用户名变长字符串(50)取件人卡号变长字符串(50)图片文件BLOB/Image补充说明该表记录数可能较多，并且有大对象表名箱体设置表（BoxSet）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N主控箱体号Int N分控箱体号Int N箱体名称变长字符串(50)所属部门名称变长字符串(50)控制用户ID 变长字符串(50) 外键补充说明该表记录数比实际分控箱体数略多，小表表名信件表（Letters）列名数据类型（精度范围）空/非空约束条件信件ID 变长字符串(50) N发信/收信变长字符串(50) N信件类型变长字符串(50) N 信/交换/汇款单/挂号信信件年份变长字符串(50)信件条码变长字符串(50) 一维条码信件号变长字符串(50) 信件条码的单元码接收单位变长字符串(255)接收二级单位变长字符串(255)接收人名称变长字符串(50) 外键箱体名变长字符串(50)箱体单位变长字符串(50)发送单位变长字符串(255)密级变长字符串(50)紧急程度变长字符串(50)限制时间Datetime大宗号变长字符串(50)备注变长字符串(255)状态变长字符串(50) 登记/箱中创建部门变长字符串(50) 外键创建人变长字符串(50) 外键创建时间Datetime修改部门变长字符串(50) 外键修改人变长字符串(50) 外键修改时间Datetime信件内容？是否直送？直送列表码？序列号？补充说明该表记录数大，此信件表删除时的Trigger转移到信件历史记录表表名信件历史记录表（LetterHistory）列名数据类型（精度范围）空/非空约束条件信件ID 变长字符串(50) N发信/收信变长字符串(50) N信件类型变长字符串(50) N 信/交换/汇款单/挂号信信件年份变长字符串(50)信件条码变长字符串(50) 一维条码信件号变长字符串(50) 信件条码的单元码接收单位变长字符串(255)接收二级单位变长字符串(255)接收人名称变长字符串(50) 外键箱体名变长字符串(50)箱体单位变长字符串(50)发送单位变长字符串(255)密级变长字符串(50)紧急程度变长字符串(50)限制时间Datetime大宗号变长字符串(50)备注变长字符串(255)状态变长字符串(50) 登记/箱中创建部门变长字符串(50) 外键创建人变长字符串(50) 外键创建时间Datetime修改部门变长字符串(50) 外键修改人变长字符串(50) 外键修改时间Datetime补充说明该表记录数大，由原来的信件表删除时的Trigger转移到此表表名信函流程跟踪表（LetterTrace）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N信函ID 变长字符串(50) N 外键连接信函表条码变长字符串(100)流程类型变长字符串(50) 登记/创建部门变长字符串(50) 外键创建人变长字符串(50) 外键创建时间Datetime补充说明该表记录数较小，因为模板一般用户自定义的个数不会太多表名大宗发信模板表（LetterBulkTpl）列名数据类型（精度范围）空/非空约束条件模板ID 变长字符串(50) N模板名称变长字符串(50) N选择单位类型变长字符串(50) N 外键单位名称变长字符串(255) N 外键二级单位名称变长字符串(50)单位用户名变长字符串(50)顺序号Int补充说明该表记录数较小，因为模板一般用户自定义的个数不会太多表名发信排序表（LetterOrder）列名数据类型（精度范围）空/非空约束条件ID 变长字符串(50) N 发送方式变长字符串(50) N单位名称变长字符串(50) N 外键信件ID 变长字符串(50) N 外键清单号变长字符串(50)排序单位变长字符串(50)排序用户名变长字符串(50)排序时间Datetime补充说明该表记录数普通，使用扫描枪录入。

数据结构实用教程( 第三版) 课后答案file:///D|/ ------------------ 上架商品---------------------- / 数据结构实用教程( 第三版)课后答案(徐孝凯著)清华大学/第一章绪论.txt第一章绪习题一一、单选题1. 一个数组元数a[i] 与( A ) 的表示等价。

A *(a+i)B a+iC *a+iD &a+i2. 对于两个函数，若函数名相同，但只是( C) 不同则不是重载函数。

A 参数类型B 参数个数C 函数类型3. 若需要利用形参直接访问实参，则应把形参变量说明为(B) 参数。

A 指针B 引用C 值4. 下面程序段的复杂度为(C ) 。

for(int i=0;i<m;i++)for(int j=0;j<n;j++)a[i][j]=i*j;A O(m2)B O(n2)C O(m*n)D O(m+n)5. 执行下面程序段时，执行S语句的次数为(D )。

for(int i=1;i<=n;i++)for(int j=1; j<=i;j++)S;A n2B n2/2C n(n+1)D n(n+1)/26. 下面算法的时间复杂度为( B) 。

int f(unsigned int n){if(n==0||n==1) return 1;Else return n*f(n-1);}A O(1)B O(n)C O(n2)D O(n!)二、填空题1. 数据的逻辑结构被除数分为集合结构、线性结构、树型结构和图形结构四种。

2. 数据的存储结构被分为顺序结构、结构、索引结构和散列结构四种。

3. 在线性结构、树型结构和图形结构中，前驱和后继结点之间分别存在着1 对1 、1 对N 和M对N的关系。

4. 一种抽象数据类型包括数据和操作两个部分。

5. 当一个形参类型的长度较大时，应最好说明为引用，以节省参数值的传输时间和存储参数的空间。

6. 当需要用一个形参访问对应的实参时，则该形参应说明为引用。

VisualFoxpro教程第三版课程设计前言Visual FoxPro（简称VFP）是一种好用而且易于开发的数据库管理程序和工具。

使用 Visual FoxPro，您可以轻松地创建数据库、表单、报表、查询和许多其他组件。

本文将针对VisualFoxpro教程第三版进行课程设计。

课程目标•熟练掌握VisualFoxpro的基本操作方法和技能；•能够独立开发一套基于VisualFoxpro的数据库管理系统；•能够解决常见的VisualFoxpro开发问题。

教学内容本课程分为以下几个部分：第一部分：VisualFoxpro基础1.VisualFoxpro的基础知识介绍；2.VisualFoxpro开发环境的配置；3.VisualFoxpro开发工具的使用；4.VisualFoxpro数据库的创建和维护；5.VisualFoxpro表单设计；6.VisualFoxpro报表设计；7.VisualFoxpro查询语言。

第二部分：VisualFoxpro进阶1.数据库的高级管理技巧；2.动态数据处理；3.事务处理；4.数据安全与维护；5.自定义组件开发；6.VisualFoxpro高级编程技巧。

第三部分：实战与案例1.实战案例解析；2.VisualFoxpro应用实战；3.VisualFoxpro数据库开发实战；4.案例分析与设计。

参考书目以下书目为VisualFoxpro教学的参考书目：1.《Visual FoxPro 9.0 开发实例教程》；2.《Visual FoxPro 之家：高效应用开发技巧与案例精讲》；3.《Visual FoxPro 程序架构设计实战指南》；4.《Visual FoxPro 9.0 高级实战》。

教学计划本课程计划为20周，每周3个课时，共60课时。

下面是课程计划内容：时间课程内容第1周VisualFoxpro基础（一）第2周VisualFoxpro基础（二）第3周VisualFoxpro基础（三）第4周VisualFoxpro表单设计（一）第5周VisualFoxpro表单设计（二）第6周VisualFoxpro表单设计（三）第7周VisualFoxpro报表设计（一）第8周VisualFoxpro报表设计（二）第9周VisualFoxpro报表设计（三）第10周VisualFoxpro查询语言（一）第11周VisualFoxpro查询语言（二）第12周VisualFoxpro查询语言（三）第13周数据库的高级管理技巧（一）第14周数据库的高级管理技巧（二）第15周数据库的高级管理技巧（三）第16周动态数据处理、事务处理与数据安全维护（一）第17周动态数据处理、事务处理与数据安全维护（二）第18周自定义组件开发与VisualFoxpro高级编程技巧第19周VisualFoxpro应用实战第20周实战案例分析与设计结语VisualFoxpro是一个非常实用的数据库管理程序和工具，学好它对职业生涯和项目开发来说非常有益益。

数据库表结构设计1. 原始单据与实体之间的关系可以是一对一、一对多、多对多的关系。

在一般情况下，它们是一对一的关系：即一张原始单据对应且只对应一个实体。

在特殊情况下，它们可能是一对多或多对一的关系，即一张原始单证对应多个实体，或多张原始单证对应一个实体。

这里的实体可以理解为基本表。

明确这种对应关系后，对我们设计录入界面大有好处。

〖例1〗：一份员工履历资料，在人力资源信息系统中，就对应三个基本表：员工基本情况表、社会关系表、工作简历表。

这就是“一张原始单证对应多个实体”的典型例子。

2. 主键与外键一般而言，一个实体不能既无主键又无外键。

在E—R 图中, 处于叶子部位的实体, 可以定义主键，也可以不定义主键(因为它无子孙), 但必须要有外键(因为它有父亲)。

主键与外键的设计，在全局数据库的设计中，占有重要地位。

当全局数据库的设计完成以后，有个美国数据库设计专家说：“键，到处都是键，除了键之外，什么也没有”，这就是他的数据库设计经验之谈，也反映了他对信息系统核心(数据模型)的高度抽象思想。

因为：主键是实体的高度抽象，主键与外键的配对，表示实体之间的连接。

3. 基本表的性质基本表与中间表、临时表不同，因为它具有如下四个特性：(1) 原子性。

基本表中的字段是不可再分解的。

(2) 原始性。

基本表中的记录是原始数据（基础数据）的记录。

(3) 演绎性。

由基本表与代码表中的数据，可以派生出所有的输出数据。

(4) 稳定性。

基本表的结构是相对稳定的，表中的记录是要长期保存的。

理解基本表的性质后，在设计数据库时，就能将基本表与中间表、临时表区分开来。

4. 范式标准基本表及其字段之间的关系, 应尽量满足第三范式。

但是，满足第三范式的数据库设计，往往不是最好的设计。

为了提高数据库的运行效率，常常需要降低范式标准：适当增加冗余，达到以空间换时间的目的。

〖例2〗：有一张存放商品的基本表，如表1所示。

“金额”这个字段的存在，表明该表的设计不满足第三范式，因为“金额”可以由“单价”乘以“数量”得到，说明“金额”是冗余字段。

数据库表的结构数据库表的结构是指数据库中存储数据的方式和组织形式的一种表示方法。

它由数据表名、字段名、数据类型、索引、约束等元素组成，用来定义和描述数据的结构和特性。

正确的数据库表结构设计不仅可以提高数据库的性能和效率，还能保证数据的完整性和一致性。

以下是数据库表结构设计的一些相关参考内容。

1. 表名：表名应该具有清晰、简洁和易于理解的含义，通常使用复数形式，避免使用过长或过于复杂的名称。

例如，学生表可以命名为"students"。

2. 字段名：字段名应该准确描述字段所代表的含义，尽量避免使用缩写或不规范的命名方式。

字段名应该使用小写字母，不同单词之间可以使用下划线或驼峰命名法分隔。

例如，学生表中的字段可以命名为"student_id"、"student_name"等。

3. 数据类型：根据不同的数据类型选择合适的数据类型来存储数据，避免浪费存储空间和提高数据读写效率。

常见的数据类型包括整数型（int）、浮点型（float）、字符串型（varchar）、日期时间型（datetime）等。

4. 索引：索引可以提高数据库的查询效率，通过在某些字段上创建索引来加快查找和排序的速度。

通常在主键和经常用于查询的字段上创建索引。

需要注意的是，索引不宜过多，否则会增加数据写入的成本。

5. 主键：主键是用来唯一标识数据表中每一个记录的字段，可以确保数据的唯一性和删除操作的准确性。

主键可以是单一字段，也可以是多个字段的组合。

常见的主键类型包括自增长整数、GUID等。

6. 外键：外键用于建立数据表之间的联系和关联，保持数据的完整性和一致性。

外键是一个指向其他表主键的字段，用来创建表之间的关系。

外键可以帮助实现表与表之间的数据一致性，并且可以确保数据的正确性。

7. 约束：约束用于限制和定义数据的完整性和一致性，可以在创建表时或者后期添加约束。

常见的约束包括主键约束、唯一约束、非空约束、默认值约束、检查约束等。

数据库基础教程第三版课程设计
1. 课程概述
数据库是当今计算机领域最常用的基础性技术之一，它是现代信息系统的核心组成部分。

本课程旨在介绍关系型数据库和SQL查询语言，通过实践项目学习关系型数据库的设计、实现和管理。

2. 课程目标
本课程的主要目的是使学生掌握以下知识和技能：
•了解关系型数据库的基本概念和原理；
•掌握SQL查询语言的基本语法和常用操作；
•能够通过实践项目设计和实现关系型数据库。

3. 课程内容
本课程主要包括以下知识点：
•关系型数据库设计理论
•SQL基础语句和操作
•数据库编程语言
•关系型数据库的应用实例和案例解析
4. 课程大纲
第一部分：关系型数据库设计理论
1.关系型数据库的基本概念和原理
2.数据表的设计和字段定义
3.主键、外键、索引和约束条件
1。

VisualFoxPro6.0数据库与程序设计第三版课程设计一、介绍VisualFoxPro6.0是一款与时俱进的数据库管理系统，在数据处理和存储方面有很多优秀的特性。

本文将介绍VisualFoxPro6.0数据库与程序设计的第三版课程设计，包括如何设计数据库和程序，以及如何使用VisualFoxPro6.0进行开发。

二、数据库设计1. 数据库创建首先，我们需要创建一个新数据库。

在VisualFoxPro6.0中，可以通过点击“文件”菜单，然后选择“新建数据库”选项来完成新数据库的创建。

2. 计划数据库架构在创建新数据库后，我们需要计划数据库架构。

在设计数据库架构时，应该考虑以下重要因素：•数据表：需要定义哪些数据表，以及每个表包含哪些字段。

•数据关系：需要确定不同数据表之间的关系，包括一对一、一对多和多对多关系。

•数据类型：需要确定每个数据表中每个字段的数据类型，以及该类型的限制。

3. 创建数据表在确定了数据库架构后，我们需要创建每个数据表并定义字段。

在VisualFoxPro6.0中，可以使用“新建表”向导来创建新表。

4. 建立数据关系通过创建“关联”新建表，在VisualFoxPro6.0中可以实现表之间的关系。

系统将会自动创建主键、外键和联合查询等功能。

5. 设计查询在VisualFoxPro6.0中，可以使用“查询”创建查询操作。

用户可以使用SQL语句或表格拖放方式创建查询操作。

三、程序设计1. 编写存储过程在VisualFoxPro6.0中，可以使用存储过程来处理复杂的数据处理逻辑。

存储过程是一段预定义的程序代码，可以使用参数传递数据，并将结果返回给调用者。

2. 使用表单在VisualFoxPro6.0中，可以使用表单创建用户界面，使用户可以使用数据表。

通过表单，用户可以直接修改、删除、添加记录。

3. 开发报表报表是一种数据可视化方式，通过图表化和表格化的方式呈现数据。

在VisualFoxPro6.0中，可以使用“报表”工具创建报表，用户可以选择数据表格、查询等。

/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) {if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e) {int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/ for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/ L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/ e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}/*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e){int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}/*文件名:algo2-3.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct DNode /*定义双链表结点类型*/{ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/} DLinkList;void InitList(DLinkList *&L){L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/ L->prior=L->next=NULL;}void DestroyList(DLinkList *&L){DLinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L){return(L->next==NULL);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/p->next=q->next; /*从单链表中删除*q结点*/if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}void Sort(DLinkList *&head) /*双链表元素排序*/{DLinkList *p=head->next,*q,*r;if (p!=NULL) /*若原双链表中有一个或以上的数据结点*/{r=p->next; /*r保存*p结点后继结点的指针*/p->next=NULL; /*构造只含一个数据结点的有序表*/p=r;while (p!=NULL){r=p->next; /*r保存*p结点后继结点的指针*/q=head;while (q->next!=NULL && q->next->data<p->data) /*在有序表中找插入*p的前驱结点*q*/q=q->next;p->next=q->next; /*将*p插入到*q之后*/if (q->next!=NULL) q->next->prior=p;q->next=p;p->prior=q;p=r;}}}/*文件名:algo2-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=L;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==L);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e){int j=0;LinkList *p;if (L->next!=L) /*单链表不为空表时*/ {if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*单链表为空表时*/return 0;}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=L && p->data!=e){p=p->next;n++;}if (p==L)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e){int j=0;LinkList *p=L,*s;if (p->next==L || i==1) /*原单链表为空表或i==1时*/ {s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}else{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;if (p->next!=L) /*原单链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}}else return 0;}/*文件名:algo2-5.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct DNode /*定义双链表结点类型*/{ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/} DLinkList;void InitList(DLinkList *&L){L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/ L->prior=L->next=L;}void DestroyList(DLinkList *&L){DLinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L){return(L->next==L);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e){int j=0;DLinkList *p;if (L->next!=L) /*双链表不为空表时*/ {if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}else /*双链表为空表时*/return 0;}int LocateElem(DLinkList *L,ElemType e){int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;if (p->next==L) /*原双链表为空表时*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/s->data=e;p->next=s;s->next=p;p->prior=s;s->prior=p;return 1;}else if (i==1) /*原双链表不为空表但i=1时*/ {s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/s->data=e;s->next=p->next;p->next=s; /*将*s插入到*p之后*/s->next->prior=s;s->prior=p;return 1;}else{p=L->next;while (j<i-2 && p!=L)p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;if (p->next!=L) /*原双链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;q->next->prior=L;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/p->next=q->next; /*从单链表中删除*q结点*/if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}}else return 0; /*原双链表为空表时*/}/*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;}int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/ struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/ s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s)LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/ return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e)if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/ {r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/ q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/{int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/{int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/ str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/ str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/ str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/ str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/ str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}/*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data) {p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)){printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)){printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)){printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}/*文件名:algo7-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str) /*由str串创建二叉链*/ {BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL; /*建立的二叉树初始时为空*/ch=str[j];while (ch!='\0') /*str未扫描完时循环*/{switch(ch){case '(':top++;St[top]=p;k=1; break; /*为左结点*/case ')':top--;break;case ',':k=2; break; /*为右结点*/default:p=(BTNode *)malloc(sizeof(BTNode));p->data=ch;p->lchild=p->rchild=NULL;if (b==NULL) /*p指向二叉树的根结点*/b=p;else /*已建立二叉树根结点*/{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}BTNode *FindNode(BTNode *b,ElemType x) /*返回data域为x的结点指针*/{BTNode *p;if (b==NULL)return NULL;else if (b->data==x)return b;else{p=FindNode(b->lchild,x);if (p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}BTNode *LchildNode(BTNode *p) /*返回*p结点的左孩子结点指针*/{return p->lchild;}BTNode *RchildNode(BTNode *p) /*返回*p结点的右孩子结点指针*/{return p->rchild;}int BTNodeDepth(BTNode *b) /*求二叉树b的深度*/{int lchilddep,rchilddep;if (b==NULL)return(0); /*空树的高度为0*/ else{lchilddep=BTNodeDepth(b->lchild); /*求左子树的高度为lchilddep*/rchilddep=BTNodeDepth(b->rchild); /*求右子树的高度为rchilddep*/return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);}}void DispBTNode(BTNode *b) /*以括号表示法输出二叉树*/{if (b!=NULL){printf("%c",b->data);if (b->lchild!=NULL || b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if (b->rchild!=NULL) printf(",");DispBTNode(b->rchild);printf(")");}}}int BTWidth(BTNode *b) /*求二叉树b的宽度*/{struct{int lno; /*结点的层次编号*/BTNode *p; /*结点指针*/} Qu[MaxSize]; /*定义顺序非循环队列*/int front,rear; /*定义队首和队尾指针*/int lnum,max,i,n;front=rear=0; /*置队列为空队*/if (b!=NULL){rear++;Qu[rear].p=b; /*根结点指针入队*/Qu[rear].lno=1; /*根结点的层次编号为1*/while (rear!=front) /*队列不为空*/{front++;b=Qu[front].p; /*队头出队*/lnum=Qu[front].lno;if (b->lchild!=NULL) /*左孩子入队*/{rear++;Qu[rear].p=b->lchild;Qu[rear].lno=lnum+1;}if (b->rchild!=NULL) /*右孩子入队*/{rear++;Qu[rear].p=b->rchild;Qu[rear].lno=lnum+1;}}max=0;lnum=1;i=1;while (i<=rear){n=0;while (i<=rear && Qu[i].lno==lnum){n++;i++;}lnum=Qu[i].lno;if (n>max) max=n;}return max;}elsereturn 0;}int Nodes(BTNode *b) /*求二叉树b的结点个数*/{int num1,num2;if (b==NULL)。

数据库系统设计实现与管理第三版课程设计一、课程设计目的数据库系统设计实现与管理是计算机科学与技术专业的一门重要基础课程，本次课程设计旨在通过实际操作，使学生能够掌握数据库系统设计与实现的基本方法和技能，提高学生在数据管理领域中的实践能力。

二、课程设计内容本次课程设计主要分为两个部分：数据库系统设计和数据库操作。

具体内容如下：2.1 数据库系统设计2.1.1 需求分析通过与需求方沟通、收集信息、整理数据，对数据库系统的需求进行分析，确定系统所需实现的功能和特点。

2.1.2 概念设计根据需求分析结果，确定数据库系统中所有实体、关系以及属性等的概念，建立概念模型（ER图）。

2.1.3 逻辑设计将概念模型转换成数据库模型，包括确定表结构、定义完整性约束，形成逻辑模型。

2.1.4 物理设计根据逻辑模型设计物理模型，包括确定存储数据的物理结构、定义索引、规划物理存储机构等。

2.1.5 数据库的建立和测试根据物理设计，建立数据库，并进行相关测试，包括创建表格、建立关系、插入数据、查询数据等。

2.2 数据库操作2.2.1 数据库的连接与断开学习数据库的连接和断开，包括建立数据库连接、执行SQL语句，关闭数据库连接等。

2.2.2 数据查询和更新学习如何进行数据查询和更新操作，包括选择语句、过滤语句、分组与聚合、更新语句以及事务处理等。

2.2.3 数据库备份和还原学习数据库备份和还原技术，包括备份方式、备份时间、备份文件处理、还原文件处理等。

三、课程设计要求3.1 需求分析报告学生需要通过收集、整理、分析需求的方法，写出数据库系统的需求报告，做好需求规格说明书的编写，详细描述系统功能和特性。

3.2 概念设计报告根据需求分析的结果，学生要绘制ER图，写出概念设计报告，详细说明各个实体、关系、属性等。

3.3 逻辑设计报告学生需要将概念设计转换成逻辑模型，写出逻辑设计报告，详细描述表结构、定义完整性约束等。

3.4 物理设计报告学生需要将逻辑设计转换成物理模型，写出物理设计报告，详细描述存储数据的物理结构、定义索引、规划物理存储机构等。