抽象数据类型的实现
第3章抽象数据类型的实现
3.1 实验概要
实验项目名称: 抽象数据类型的实现
实验项目性质: 设计性实验
所属课程名称: 数据结构
实验计划学时: 6
3.2 实验目的
对某个具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。进而达到熟练地运用本课程中的基础知识及技术的目的。
3.3 预习与参考
1．确定要实现的抽象数据类型，并对基本操作做适当的选取和增加；
2．选择存储结构，并写出相应的类型定义；
3．设计各基本操作的实现算法，并表达为函数形式；
4．设计测试方案，编写主函数；
5．将上述4步的结果写成预习报告。
3.4 实验要求和设计指标
以教材中线性表，串，稀疏矩阵，广义表，二叉树，树，图以及查找表等抽象数据类型为对象，利用C语言的数据类型表示和实现其中某个抽象数据类型。
可选的抽象数据类型如下表所列：
注：如果基本操作数量较多，可选择实现其中一个基本操作子集。
实验要求如下：
1．参加实验的学生应首先了解设计的任务，然后根据自己的基础和能力从中选择一题。一般来说，选择题目应以在规定的时间内能完成，并能得到应有的锻炼为原则。若学生对教材以外的相关题目较感兴趣，希望选作实验的题目时，应征得指导教师的认可，并写出明确的抽象数据类型定义及说明。
2. 实验前要作好充分准备，包括：理解实验要求，掌握辅助工具的使用，了解该抽象数据类型的定义及意义，以及其基本操作的算法并设计合理的存储结构。
3. 实验时严肃认真，要严格按照要求独立进行设计，不能随意更改。注意观察并记录各种错误现象，纠正错误，使程序满足预定的要求，实验记录应作为实验报告的一部分。
4. 实验后要及时总结，写出实验报告，并附所打印的问题解答、程序清单，所输入的数据及相应的运行结果。
3.5 实验仪器设备和材料
软件实验室。
编程环境：Anyview C可视化编程环境、TC++、C++Builder或者VC++。
3.6 调试及结果测试
调试内容应包括：调试过程中遇到的问题是如何解决的以及对实验的讨论与分析；基本操作的时间复杂度和空间复杂度的分析和改进设想。列出对每一个基本操作的测试结果，包括输入和输出，测试数据应完整和严格。
3.7 考核形式
考核形式以实验过程和实验报告相结合的方式进行。在实验完成后，应当场运行和答辩，由指导教师验收，只有在验收合格后才能算实验部分的结束。实验报告作为整个设计性实验评分的书面依据。设计性实验的成绩评定以选定题目的难易度、完成情况和实验报告为依据综合评分。从总体来说，所实现的抽象数据类型应该全部符合要求，类型定义，各基本操作的算法以及存储结构清晰；各模快测试运行正确；程序的结构合理；设计报告符合规范。
3.8 实验报告要求
实验结束后要写出实验报告，以作为整个设计性实验评分的书面依据和存档材料。实验报告是反映学生实验效果的最主要的依据，也是学生正确地表达问题、综合问题和发现问题的能力的基本培养手段，因而是非常重要的内容。本设计性实验的报告要包括以下几项内容：（1）设计任务、要求及所用软件环境或工具；
（2）抽象数据类型定义以及各基本操作的简要描述；
（3）所选择的存储结构描述及在此存储结构上各基本操作的实现；
（4）程序清单（计算机打印），输入的数据及各基本操作的测试结果；
（5）实验总结和体会。
实验报告以规定格式的电子文档书写、打印并装订，排版及图表要清楚、工整。
3.9 思考题
对设计性实验进行总结和讨论，包括本实验的优、缺点，数据存储结构的特点，与其它存储结构之间的比较等。通过总结，可以对抽象数据类型有更全面、深入的认识，这是设计性实验不可缺少的重要内容。这部分内容应作为实验报告中的一个组成部分。
3.10 示例
1. 题目
采用字符类型为元素类型和无头结点单链表为存储结构，实现抽象数据类型List。
ADT List{
数据对象：D＝{ a i | a i∈ElemSet, i=1,2,...,n, n≥0 }
数据关系：R1＝{ |a i-1, a i∈D, i=2,...,n }
基本操作：
SetEmpty(&L)
操作结果：构造一个空的线性表L。
Destroy(&L)
初始条件：线性表L已存在。
操作结果：销毁线性表L。
Length(L)
初始条件：线性表L已存在。
操作结果：返回L中元素个数。
Get(L, i, &e)
初始条件：线性表L已存在，1≤i≤LengthList(L)。
操作结果：用e返回L中第i个元素的值。
Locate(L, e, compare())
初始条件：线性表L已存在，compare()是元素判定函数。
操作结果：返回L中第1个与e满足关系compare()的元素的位序。
若这样的元素不存在，则返回值为0。
Insert(&L, i, e)
初始条件：线性表L已存在，1≤i≤LengthList(L)+1。
操作结果：在L的第i个元素之前插入新的元素e，L的长度加1。
Delete(&L, i, &e)
初始条件：线性表L已存在且非空，1≤i≤LengthList(L)。
操作结果：删除L的第i个元素，并用e返回其值，L的长度减1。
Display(L)
初始条件：线性表L已存在。
操作结果：依次输出L的每个元素。
} ADT List
2．存储结构定义
公用头文件DS0.h:
#include
#include
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define IBFEASIBLE -1
#define OVERFLOW -2
#define MAXLEN 20
#define MAXSIZE 20
typedef int Status;
typedef char ElemType; /* 元素类型为字符类型*/
（1）顺序存储结构
#define LIST_INIT_SIZE 20 /*线性表存储空间的初始分配量*/
#define LISTINCREMENT 10 /*线性表存储空间的分配增量*/
typedef struct{
ElemType *elem; /*存储空间基址*/
int length; /*当前长度*/
int listsize; /*当前分配的存储容量*/
} SqList;
（2）无头结点单链表存储结构
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LList; /* 不带头结点单链表类型*/
（3）带头结点单链表存储结构
typedef struct LNode { /* 结点类型 */
ElemType data;
struct LNode *next;
} LNode, *Link, *Position;
typedef struct LinkList { /* 链表类型 */
Link head,tail; /* 分别指向线性链表中的头结点和最后一个结
点 */
int len; /* 指示线性链表中数据元素的个数 */ } LinkList;
3. 算法设计
（1）顺序存储结构
Status SetEmpty(SqList &L) { /*构造一个空的顺序线性表 */
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemTyp
e));
if(!L.elem)
return OVERFLOW; /* 存储分配失败 */
L.length=0; /* 空表长度为0 */
L.listsize=LIST_INIT_SIZE; /* 初始存储容量 */ return OK;
}
Status Destroy (SqList &L) { /*销毁顺序线性表L */
free(L.elem);
L.elem=NULL;
L.length=0;
L.listsize=0;
return OK;
}
int Length(SqList L) { /* 求表长*/
return L.length;
}
Status Get(SqList &L, int i, ElemType &e) { /* 获取第i元素 */
if(i<1||i>L.length)
return ERROR;
e=*(L.elem+i-1);
return OK;
}
int Locate(SqList L, ElemType x) { /* 确定x在表中的位序 */ ElemType *p;
int i=1; /* i的初值为第1个元素的位序 */
p=L.elem; /* p的初值为第1个元素的存储位置 */
while(i<=L.length && *p++!=x)
++i;
if(i<=L.length)
return i;
else
return 0;
}
Status Insert(SqList &L, int i, ElemType e) {
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) /* i值不合法 */
return ERROR;
if(L.length>= L.listsize) { /* 当前存储空间已满,增加分配*/
newbase=(ElemType *) realloc(L.elem,
(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) return OVERFLOW; /* 存储分配失败 */ L.elem=newbase; /* 新基址 */
L.listsize+=LISTINCREMENT; /* 增加存储容量 */
}
q=L.elem+i-1; /* q为插入位置 */
for(p=L.elem+L.length-1; p>=q; --p)
*(p+1)=*p; /* 插入位置及之后的元素右移 */
*q=e; /* 插入e */
++L.length; /* 表长增1 */
return OK;
}
Status Delete(SqList &L, int i, ElemType &e) { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */ /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
ElemType *p,*q;
if(i<1||i> L.length) /* i值不合法 */
return ERROR;
p= L.elem+i-1; /* p为被删除元素的位置 */
e=*p; /* 被删除元素的值赋给e */
q= L.elem+L.length-1; /* 表尾元素的位置 */
for(++p; p<=q; ++p) /* 被删除元素之后的元素左移 */ *(p-1)=*p;
L.length--; /* 表长减1 */
return OK;
}
Status Display(SqList L) { /* 依次显示表中元素 */
ElemType *p;
int i;
p=L.elem;
printf("( ");
for(i=1; i<=L.length; i++)
printf("%c",*p++);
printf(" )\n");
return OK;
}
（2）无头结点单链表
void SetEmpty(LList &L) { /* 置无头结点的空单链表*/
L=NULL;
}
Status Destroy (LList &L) { /* 销毁链表*/
LList q=L;
while(L) {
L=L->next;
free(q);
q=L;
}
return OK;
}
int Length(LList L) { /* 求表长*/
int n=0;
while(L!=NULL) {
n++;
L=L->next;
}
return n;
}
Status Get(LList L, int i, ElemType &e) { /* 获取第i元素*/
int j=1;
while (j
L=L->next;
j++;
}
if(L!=NULL) { e=L->data; return OK; }
else return ERROR; /* 位置参数i不正确 */
}
int Locate(LList L, ElemType x) { /* 确定x在表中的位序 */ int n=1;
while (L!=NULL && L->data!=x) {
L=L->next;
n++;
}
if (L==NULL) return 0;
else return n;
}
Status Insert(LList &L, int i, ElemType e) { /* 插入第i 元素*/
int j=1;
LList s,q;
s=(LList)malloc(sizeof(LNode));
s->data=e;
q=L;
if (i==1) { s->next=q; L=s; return OK;}
else {
while(j
q=q->next;
j++;
if (j==i-1) {
s->next=q->next;
q->next=s;
return OK;
}
else return ERROR; /* 位置参数i不正确 */ }
}
Status Delete(LList &L, int i, ElemType &e) { /* 删除第i 元素*/
int j=1;
LList q=L,t;
if (i==1) {
e=q->data;
L=q->next;
free(q);
return OK;
}
else {
while (j
q=q->next;
j++;
}
if (q->next!=NULL && j==i-1) {
t=q->next;
q->next=t->next;
e=t->data;
free(t);
return OK;
}
else return ERROR; /* 位置参数i不正确*/
}
}
void Display(LList L) { /* 依次显示表中元素 */
printf("单链表显示: ");
if (L==NULL)
printf("链表为空!");
else if (L->next==NULL)
printf("%c\n", L->data);
else {
while(L->next!=NULL) {
printf("%c->", L->data);
L=L->next;
printf("%c", L->data);
}
printf("\n");
}
（3）带头结点单链表
Status SetEmpty(LinkList &L) { /* 置带头结点的空单链表*/
Link p;
p=(Link)malloc(sizeof(LNode)); /* 生成头结点 */ if(p) {
p->next=NULL;
L.head=L.tail=p;
L.len=0;
return OK;
}
else
return ERROR;
}
Status Destroy(LinkList &L) {/* 销毁线性链表L，L不再存在 */ Link p,q;
if(L.head!=L.tail) { /* 不是空表 */
p=q= L.head->next;
L.head->next=NULL;
while(p!=L.tail) {
p=q->next;
free(q);
q=p;
}
free(q);
}
free(L.head);
L.head=L.tail=NULL;
L.len=0;
return OK;
}
int Length(LinkList L) { /* 返回线性链表L中元素个数 */ return L.len;
}
Status Get(LinkList L, int i, ElemType &e) { /* 获取第i 元素 */
/* i=0为头结点 */
Link p;
int j;
if(i<1||i>L.len)
return ERROR;
else{
p=L.head;
for(j=1;j<=i;j++)
p=p->next;
e=p->data;
return OK;
}
}
int Locate(LinkList L, ElemType x) { /* 确定x在表中的位序*/
int i=0;
Link p=L.head;
do {
p=p->next;
i++;
} while(p && p->data!=x); /* 没到表尾且没找到满足关系的元素 */
if (!p)
return 0;
else
return i;
}
Status Insert(LinkList &L, int i, ElemType e) { /* 插入第i元素*/
int j=0;
Link s,q;
s=(Link)malloc(sizeof(LNode));
s->data=e;
q=L.head;
while(j
q=q->next;
j++;
}
if (j==i-1) {
s->next=q->next;
q->next=s;
if (L.tail==q) L.tail=s;
L.len++;
return OK;
}
else return ERROR; /* 位置参数i不正确 */
}
Status Delete(LinkList &L, int i, ElemType &e) {
/* 删除第i元素*/
int j=0;
Link q=L.head,t;
while (j
q=q->next;
j++;
}
if (q->next!=NULL && j==i-1) {
t=q->next;
q->next=t->next;
e=t->data;
if(L.tail==t) L.tail=q;
free(t);
L.len--;
return OK;
}
else return ERROR; /* 位置参数i不正确*/
}
void Display(LinkList L) { /* 依次显示表中元素 */
Link p;
printf("单链表显示: ");
if (L.head==L.tail)
printf("链表为空!");
else {
p=L.head->next;
while(p->next!=NULL) {
printf("%c->", p->data);
p=p->next;
}
printf("%c", p->data);
}
printf("\n");
}
4．测试
（1）顺序存储结构
SqList head;
void main() { /* 主函数*/
char e,c;
int i,n,select,x1,x2,x3,x4,m,g;
SetEmpty(head);
n=random(8); /* 随机产生表长 */
for (i=1; i<=n; i++) { /* 将数据插入到顺序表中 */ c='A'+random(26);
Insert(head,i,c);
}
do{
Display(head);
printf("select 1 求长度 Length()\n");
printf("select 2 取结点 Get()\n");
printf("select 3 求值查找 Locate()\n");
printf("select 4 删除结点 Delete()\n");
printf("input your select: ");
scanf("%d",&select);
switch(select) {
case 1: x1=Length(head);
printf("顺序表的长度:%d ",x1);
break;
case 2: printf("请输入要取的结点序号: ");
scanf("%d",&m);
if(Get(head,m,x2)) printf("%c\n",x2);
else printf("错误\n");
break;
case 3: printf("请输入要查找的数据元素: ");
scanf("\n%c",&e);
x3=Locate(head,e);
printf("%d\n",x3);
break;
case 4: printf("请输入要删除的元素序号: ");
scanf("%d",&g);
if(Delete(head,g,x4))
printf("%c\n",x4);
else printf("错误\n");
break;
}
} while (select>0 && select <5);
}
（2）无头结点单链表
LList head;
void main() { /* 主函数*/
char e,c;
int i,n,select,x1,x2,x3,x4,m,g;
SetEmpty(head);
n=random(8); /* 随机产生表长 */
for (i=1; i<=n; i++) { /* 将数据插入到顺序表中 */ c='A'+random(26);
Insert(head,i,c);
}
do{
Display(head);
printf("select 1 求长度 Length()\n");
printf("select 2 取结点 Get()\n");
printf("select 3 求值查找 Locate()\n");
printf("select 4 删除结点 Delete()\n");
printf("input your select: ");
scanf("%d",&select);
switch(select) {
case 1: x1=Length(head);
printf("顺序表的长度:%d ",x1);
break;
case 2: printf("请输入要取的结点序号: ");
scanf("%d",&m);
if(Get(head,m,x2)) printf("%c\n",x2);
else printf("错误\n");
break;
case 3: printf("请输入要查找的数据元素: ");
scanf("\n%c",&e);
x3=Locate(head,e);
printf("%d\n",x3);
break;
case 4: printf("请输入要删除的元素序号: ");
scanf("%d",&g);
if(Delete(head,g,x4))
printf("%c\n",x4);
else printf("错误\n");
break;
}
} while (select>0 && select <5);
}
（3）带头结点单链表
LinkList head;
void main() { /* 主函数*/
char e,c;
int i,n,select,x1,x2,x3,x4,m,g;
SetEmpty(head);
n=random(8); /* 随机产生表长 */
for (i=1; i<=n; i++) { /* 将数据插入到顺序表中 */ c='A'+random(26);
Insert(head,i,c);
}
do {
Display(head);
printf("select 1 求长度 Length()\n");
printf("select 2 取结点 Get()\n");
printf("select 3 求值查找 Locate()\n");
printf("select 4 删除结点 Delete()\n");
printf("input your select: ");
scanf("%d",&select);
switch(select) {
case 1: x1=Length(head);
printf("顺序表的长度:%d ",x1);
break;
case 2: printf("请输入要取的结点序号: ");
scanf("%d",&m);
if(Get(head,m,x2)) printf("%c\n",x2);
else printf("错误\n");
break;
case 3: printf("请输入要查找的数据元素: ");
scanf("\n%c",&e);
x3=Locate(head,e);
printf("%d\n",x3);
break;
case 4: printf("请输入要删除的元素序号: ");
scanf("%d",&g);
if(Delete(head,g,x4))
printf("%c\n",x4);
else printf("错误\n");
break;
}
} while (select>0 && select<5);
}
5．三种存储结构的比较
6．思考与小结
（1）无头结点单链表的插入和删除操作的实现，要区分该表是否为空，并编写相应的代码。
（2）在算法设计时，要注意判断有关参数值的合法性。
（3）三种存储结构的主函数相同。设计主函数及测试运行时，要考虑测试的完备性。
7．预习报告和实验报告
（1）预习报告：包括1-4步的初稿。
（2）实验报告：在预习报告的基础上，增加在实验中，对算法修改核调试的收获体会，以及思考和小结的内容。
有理数抽象数据类型定义
ADT Rational { //起名要易懂 数据对象：D={e1,e2|e1,e2∈Z,e2≠0} //分母不为零 数据关系：R={
Status InitRational(Rational &Q,ElemType v1, ElemType v2){ //构造有理数Q，分子分母分别为v1,v2，若v2=0则Q赋空，返回Error if(v2==0){Q=NULL;return ERROR;} /*return后括号可有可无*/ Q=(ElemType *)malloc(2*sizeof(ElemType)); //莫忘malloc.h if(!Q)exit(OVERFLOW);//分配存储空间失败, stdlib.h,注意!及适用场合用法Q[0]=v1;Q[1]=v2; /*之前的else可省略，若不省略最好加花括号*/ return(OK); } Status DestroyRational(Rational &Q) //销毁有理数Q { if(Q) { free(Q); Q=NULL; return OK; } } void OutputRational(Rational Q){ //以分数形式输出有理数Q if(!Q)printf(“the rational does not exist! \n‘); printf(“ %d/%d ”,Q[0],Q[1]); }
严蔚敏版数据结构课后习题答案-完整版
第1章绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 存储结构是数据结构在计算机中的表示。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数据
类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。 1.3 设有数据结构(D,R)，其中 {}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。 解： 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解： ADT Complex{ 数据对象：D={r,i|r,i 为实数} 数据关系：R={
数据结构串的比较
上机5 设计strcmp（s，t）算法，实现两个串和的比较 代码： #include (1) 整数型 整数包括bigint、int、smallint和tinyint，从标识符的含义就可以看出，它们的表示数范围逐渐缩小。 l bigint：大整数，数范围为-263 (-9223372036854775808)～263-1 (9223372036854775807) ，其精度为19，小数位数为0，长度为8字节。 l int：整数，数范围为-231 (-2,147,483,648) ～231 - 1 (2,147,483,647) ，其精度为10，小数位数为0，长度为4字节。 l smallint：短整数，数范围为-215 (-32768) ～215 - 1 (32767) ，其精度为5，小数位数为0，长度为2字节。 l tinyint：微短整数，数范围为0～255，长度为1字节，其精度为3，小数位数为0，长度为1字节。 (2) 精确整数型 精确整数型数据由整数部分和小数部分构成，其所有的数字都是有效位，能够以完整的精度存储十进制数。精确整数型包括decimal 和numeric两类。从功能上说两者完全等价，两者的唯一区别在于decimal不能用于带有identity关键字的列。 声明精确整数型数据的格式是numeric | decimal(p[,s])，其中p为精度，s为小数位数，s的缺省值为0。例如指定某列为精确整数型，精度为6，小数位数为3，即decimal(6,3)，那么若向某记录的该列赋值56.342689时，该列实际存储的是56.3427。 decimal和numeric可存储从-1038 +1 到1038 –1 的固定精度和小数位的数字数据，它们的存储长度随精度变化而变化，最少为5字节，最多为17字节。 l 精度为1～9时，存储字节长度为5； l 精度为10～19时，存储字节长度为9； l 精度为20～28时，存储字节长度为13； l 精度为29～38时，存储字节长度为17。 例如若有声明numeric(8,3)，则存储该类型数据需5字节，而若有声明numeric(22,5)，则存储该类型数据需13字节。 注意：声明精确整数型数据时，其小数位数必须小于精度；在给精确整数型数据赋值时，必须使所赋数据的整数部分位数不大于列的整数部分的长度。 (3) 浮点型 浮点型也称近似数值型。顾名思义，这种类型不能提供精确表示数据的精度，使用这种类型来存储某些数值时，有可能会损失一些精度，所以它可用于处理取值范围非常大且对精确度要求不是十分高的数值量，如一些统计量。 Excel中常用的数据类型 在Excel的单元格中可以输入多种类型的数据，如文本、数值、日期、时间等等。下面简单介绍这几种类型的数据。 1．字符型数据。在Excel中，字符型数据包括汉字、英文字母、空格等，每个单元格最多可容纳32000个字符。默认情况下，字符数据自动沿单元格左边对齐。当输入的字符串超出了当前单元格的宽度时，如果右边相邻单元格里没有数据，那么字符串会往右延伸；如果右边单元格有数据，超出的那部分数据就会隐藏起来，只有把单元格的宽度变大后才能显示出来。 如果要输入的字符串全部由数字组成，如邮政编码、电话号码、存折帐号等，为了避免Excel把它按数值型数据处理，在输入时可以先输一个单引号“'”(英文符号)，再接着输入具体的数字。例如，要在单元格中输入电话号码“64016633”，先连续输入“'64016633”，然后敲回车键，出现在单元格里的就是“64016633”，并自动左对齐。 2．数值型数据。在Excel中，数值型数据包括0~9中的数字以及含有正号、负号、货币符号、百分号等任一种符号的数据。默认情况下，数值自动沿单元格右边对齐。在输入过程中，有以下两种比较特殊的情况要注意。 (1)负数：在数值前加一个“”号或把数值放在括号里，都可以输入负数，例如要在单元格中输入“66”，可以连续输入“66”“(66)”，然后敲回车键都可以在单元格中出现“66”。 (2)分数：要在单元格中输入分数形式的数据，应先在编辑框中输入“0”和一个空格，然后再输入分数，否则Excel会把分数当作日期处理。例如，要在单元格中输入分数“2/3”，在编辑框中输入“0”和一个空格，然后接着输入“2/3”，敲一下回车键，单元格中就会出现分数“2/3”。 3．日期型数据和时间型数据。在人事管理中，经常需要录入一些日期型的数据，在录入过程中要注意以下几点： (1)输入日期时，年、月、日之间要用“/”号或“-”号隔开，如“2002-8-16”“2002/8/16”。 (2)输入时间时，时、分、秒之间要用冒号隔开，如“10:29:36”。 (3)若要在单元格中同时输入日期和时间，日期和时间之间应该用空格隔开。 （信息技术教育室供稿） 实验三串 //串的基本操作 #include "stdio.h" #include "stdlib.h" #define MAXSTRLEN 255 typedef unsigned char SString[MAXSTRLEN+1]; void strlength(SString S)//求字串并放到 S[0] 中 { int m; for(m=1;S[m]!='\0';m++); S[0]=m-1; } void insert(SString S,int n,char a)//是插入的位置 a 是插入的字符{ strlength(S); int i; for(i=S[0];i>=n;i--) S[i+1]=S[i]; S[n]=a; S[S[0]+2]='\0'; } int compare(SString S,SString T) { strlength(S); strlength(T); int i; for(i=1;i<=S[0]&&i<=T[0];i++) { if(S[i]>T[i]) return 1; if(S[i] else if(S[0] 刚接触编程地朋友往往对许多数据类型地转换感到迷惑不解，本文将介绍一些常用数据类型地使用. 我们先定义一些常见类型变量借以说明 ; ; ; ; []"程佩君"; []; *; ; ; ; 一、其它数据类型转换为字符串 短整型() ()将转换为字符串放入中,最后一个数字表示十进制 (); 按二进制方式转换 长整型() (); 浮点数() 用可以完成转换,这是中地例子: , ; *; ; ( , , , ); 运行结果: : '' : : 资料个人收集整理，勿做商业用途 表示小数点地位置表示符号为正数，为负数 变量 "北京奥运"; ()(); 变量 ("程序员"); * (); 资料个人收集整理，勿做商业用途 (); (); (); 变量 (""); * (); 资料个人收集整理，勿做商业用途 (); (); 变量 类型是对地封装，因为已经重载了操作符，所以很容易使用 (""); * 不要修改中地内容 (); 通用方法(针对非数据类型) 用完成转换 []; ''; ; ; ; ( , ""); ( , ""); ( , ""); ( , ""); 二、字符串转换为其它数据类型 (,""); 短整型() (); 长整型() (); 浮点() (); 变量 ; 变量 ("程序员"); 完成对地使用 (); 变量 类型变量可以直接赋值 (""); (); 变量 类型地变量可以直接赋值 (""); (); 三、其它数据类型转换到 使用地成员函数来转换,例如: 整数() (""); 浮点数() (""); 字符串指针( *)等已经被构造函数支持地数据类型可以直接赋值 ; 对于所不支持地数据类型，可以通过上面所说地关于其它数据类型转化到*地方法先转到*， 3.2C语言的基本数据类型及其表示 C语言的基本数据类型包括整型数据、实型数据和字符型数据，这些不同数据类型如何表示？如何使用？它们的数据范围是什么？下面我们分别进行介绍。 3.2.1常量与变量 1.常量 常量是指程序在运行时其值不能改变的量，它是Ｃ语言中使用的基本数据对 象之一。Ｃ语言提供的常量有： 以上是常量所具有的类型属性，这些类型决定了各种常量所占存储空间的大小和数的表示范围。在C程序中，常量是直接以自身的存在形式体现其值和类型，例如：123是一个整型常量，占两个存储字节，数的表示范围是-32768～32767；123.0是实型常量，占四个存储字节，数的表示范围是-3.410-38～3.41038。 需要注意的是，常量并不占内存，在程序运行时它作为操作对象直接出现在运算器的各种寄存器中。 2.符号常量 在C程序中，常量除了以自身的存在形式直接表示之外，还可以用标识符来表示常量。因为经常碰到这样的问题：常量本身是一个较长的字符序列，且在程序中重复出现，例如：取常数的值为3.1415927，如果在程序中多处出现，直接使用3.1415927的表示形式，势必会使编程工作显得繁琐，而且，当需要把的值修改为3.1415926536时，就必须逐个查找并修改，这样，会降低程序的可修改性和灵活性。因此，Ｃ语言中提供了一种符号常量，即用指定的标识符来表示某个常量，在程序中需要使用该常量时就可直接引用标识符。 Ｃ语言中用宏定义命令对符号常量进行定义，其定义形式如下： #define标识符常量 其中#define是宏定义命令的专用定义符，标识符是对常量的命名，常量可以是前面介绍的几种类型常量中的任何一种。该使指定的标识符来代表指定的常量，这个被指定的标识符就称为符号常量。例如，在C程序中，要用PAI代表实型常量3.1415927，用W代表字符串常量"Windows98"，可用下面两个宏定义命令： #define PAI3.1415927 #define W"Windows98" 宏定义的功能是：在编译预处理时，将程序中宏定义（关于编译预处理和宏定义的概念详见9.10节）命令之后出现的所有符号常量用宏定义命令中对应的常量一一替代。例如，对于以上两个宏定义命令，编译程序时，编译系统首先将程序中除这两个宏定义命令之外的所有PAI替换为3.1415927，所有W替换为Windows98。因此，符号常量通常也被称为宏替换名。 习惯上人们把符号常量名用大写字母表示，而把变量名用小写字母表示。例3-1是符号常量的一个简单的应用。其中，PI为定义的符号常量，程序编译时，用3.1416替换所有的PI。 例3-1：已知圆半径r，求圆周长c和圆面积s的值。 抽象数据类型线性表的定义如下： ADT List { 数据对象：D={ a i | a i∈ElemSet, i =1, 2, ……, n, n≥0} 数据关系：R1 = { < a i-1 , a i > | a i-1 , a i ∈D, i =2, ……, n } 基本操作： InitList (&L ) 操作结果：构造一个空的线性表L 。 DestoryList (&L) 初始条件：线性表L已存在。 操作结果：销毁线性表L。 ClearList (&L) 初始条件：线性表L已存在。 操作结果：将L重置为空表。 ListEmpty (L) 初始条件：线性表L已存在。 操作结果：若L 为空表，则返回TRUE，否则返回FALSE。 ListLength (L) 初始条件：线性表L已存在。 操作结果：返回L中数据元素个数。 GetElem ( L, i, &e ) 初始条件：线性表L已存在，1≤i≤ListLength(L)+1。 操作结果：用e返回L中第i个数据元素的值。 LocateElem ( L,e, compare() ) 初始条件：线性表L已存在，compare()是判定函数。 操作结果：返回L中第1个与e满足关系compare() 的数据元素的位序。若这样的数据元素不存在，则返 回值0。 PriorElem ( L, cur_e, &pre_e ) 初始条件：线性表L已存在。 操作结果：若cur_e是L的数据元素且不是第1个， 则用pre_e返回它的前驱，否则操作失败。 NextElem ( L, cur_e, &next_e ) 初始条件：线性表L已存在。 操作结果：若cur_e是L的数据元素且不是最后一个， 则用next_e返回它的后继，否则操作失败。 ListInsert ( &L, i, e ) 初始条件：线性表L已存在，1≤i≤ListLength(L)+1。 操作结果：在L中第i个位置之前插入新的数据元素e， L的长度加1。 ListDelete( &L, i, &e ) 初始条件：线性表L已存在且非空，1≤i≤ListLength(L)。 操作结果：删除L的第i个数据元素，并用e返回其值， Java中几种常用的数据类型之间转换方法：1.短整型-->整型 如: short shortvar=0; int intvar=0; shortvar= (short) intvar 2.整型-->短整型 如: short shortvar=0; int intvar=0; intvar=shortvar; 3.整型->字符串型 如: int intvar=1; String stringvar; Stringvar=string.valueOf (intvar); 4.浮点型->字符串型 如: float floatvar=9.99f; String stringvar; Stringvar=String.valueOf (floatvar); 5.双精度型->字符串型 如： double doublevar=99999999.99; String stringvar; Stringvar=String.valueOf (doublevar); 6. 字符型->字符串型 如：char charvar=’a’; String stringvar; Stringvar=String.valueOf (charvar); 7字符串型->整型、浮点型、长整型、双精度型如：String intstring=”10”; String floatstring=”10.1f”; String longstring=”99999999”; String doubleString=”99999999.9”; Int I=Integer.parseInt (intstring); Float f= Integer.parseInt (floatstring); Long lo=long. parseInt (longstring); Double d=double. parseInt (doublestring); 8字符串型->字节型、短整型 如：String s=”0”; Byte b=Integer.intValue(s); Short sh=Integer.intValue(s); 9字符串型->字符型 如： String s=”abc”; Char a=s.charAt(0); 10字符串型-->布尔型 String s=”true”; Boolean flag=Boolean.valueOf (“s”); 实验一抽象数据类型的表示与实现 一．实验目的及要求 （1）熟悉类C语言的描述方法，学会将类C语言描述的算法转换为C源程序实现； （2）理解抽象数据类型的定义，编写完整的程序实现一个抽象数据类型（如三元组）； （3）认真阅读和掌握本实验的参考程序，上机运行程序，保存和打印出程序的运行结果，并结合程序进行分析。 二．实验内容 （1）编程实现对一组从键盘输入的数据，计算它们的最大值、最小值等，并输出。 要求：将计算过程写成一个函数，并采用引用参数实现值的求解。 （2）编程实现抽象数据类型三元组的定义、存储和基本操作，并设计一个主菜单完成各个功能的调用。 三．实验主要流程、基本操作或核心代码、算法片段（该部分如不够填写，请另加附页）（1）编程实现对一组从键盘输入的数据，计算它们的最大值、最小值等，并输出。 要求：将计算过程写成一个函数，并采用引用参数实现值的求解。 程序代码部分： 头文件： #define N 10000 void comparason(double a[],int n,double &max,double &min); 主函数： #include"" #include"" int main() { int n; printf("请输入数据个数\n"); scanf("%d",&n); double a[N],max,min; int i; printf("请输入数据（空格隔开）\n"); for(i=0;i 专题1 数据结构分类与抽象数据类型 1.1 数据结构分类 数据结构讨论现实世界和计算机世界中的数据及其相互之间的联系，这体现在逻辑和存储两个层面上，相应称之为逻辑结构和存储结构。也就是说，在现实世界中讨论的数据结构是指逻辑结构，在计算机世界中讨论的数据结构是指存储结构，又称为物理结构。 数据的逻辑结构总体上分为4种类型：集合结构、线性结构、树结构和图结构。数据的存储结构总体上也分为4种类型：顺序结构、链接结构、索引结构和散列结构。原则上，一种逻辑结构可以采用任一种存储结构来存储（表示）。 对于现实世界中的同一种数据，根据研究问题的角度不同，将会选用不同的逻辑结构；对于一种逻辑结构，根据处理问题的要求不同，将会选用不同的存储结构。 对于复杂的数据结构，不论从逻辑层面上还是从存储层面上看，都可能包含有多个嵌套层次。如假定一种数据结构包含有两个层次，第一层（顶层）的逻辑结构可能是树结构，存储结构可能是链接结构；第二层（底层）的逻辑结构可能是线性结构，存储结构可能是顺序结构。第一层结构就是数据的总体结构，第二层结构就是第一层中数据元素的结构。 数据的逻辑结构通常采用二元组来描述，其中一元为数据元素的集合，另一元为元素之间逻辑关系的集合，每一个逻辑关系是元素序偶的集合，如 #include 数据结构实验报告-串 实验四串 【实验目的】 1、掌握串的存储表示及基本操作； 2、掌握串的两种模式匹配算法：BF和KMP。 3、了解串的应用。 【实验学时】 2学时 【实验预习】 回答以下问题： 1、串和子串的定义 串的定义：串是由零个或多个任意字符组成的有限序列。 子串的定义：串中任意连续字符组成的子序列称为该串的子串。 2、串的模式匹配 串的模式匹配即子串定位是一种重要的串运算。设s和t是给定的两个串，从主串s的第start个字符开始查找等于子串t的过程称为模式匹配，如果在S中找到等于t的子串，则称匹配成功，函数返回t在s中首次出现的存储位置 （或序号）；否则，匹配失败，返回0。 【实验内容和要求】 1、按照要求完成程序exp4_1.c，实现串的相关操作。调试并运行如下测试数据给出运行结果： ?求“This is a boy”的串长； ?比较”abc ?3”和“abcde“； 表示空格?比较”english”和“student“； ?比较”abc”和“abc“； ?截取串”white”，起始2，长度2； ?截取串”white”，起始1，长度7； ?截取串”white”，起始6，长度2； ?连接串”asddffgh”和”12344”； #include { char data[MAXSIZE]; int length; } SqString; int strInit(SqString *s); /*初始化串*/ int strCreate(SqString *s); /*生成一个串*/ int strLength(SqString *s); /*求串的长度*/ int strCompare(SqString *s1,SqString *s2); /*两个串的比较*/ int subString(SqString *sub,SqString *s,int pos,int len); /*求子串*/ int strConcat(SqString *t,SqString *s1,SqString *s2); /*两个串的连接*/ /*初始化串*/ int strInit(SqString *s) { s->length=0; S7-300的数据类型分以下三种： 基本数据类型、复合数据类型和参数类型。 一、基本数据类型 1、位（bit) 常称为BOOL（布尔型），只有两个值：0或1。 如：I0.0，Q0.1，M0.0，V0.1等。 2、字节（Byte）一个字节（Byte）等于8位（Bit），其中0位为最低位，7位为最高位。如：IB0（包括I0.0～I0.7位），QB0（包括Q0.0～Q0.7位），MB0，VB0等。范围：00～FF（十进制的0～255）。 3、字（Word) 相邻的两字节（Byte）组成一个字（Word），来表示一个无符号数，因此，字为16位。 如：IW0是由IB0和IB1组成的，其中I是区域标识符，W表示字，0是字的起始字节。 需要注意的是，字的起始字节（如上例中的“0”）都必须是偶数。 字的范围为十六进制的0000～FFFF（即十进制的0～65536）。 在编程时要注意，如果已经用了IW0，如再用IB0或IB1要特别加以小心。 4、双字（Double Word） 相邻的两个字（Word）组成一个双字，来表示一个无符号数。因此，双字为32位。 如：MD100是由MW100和MW102组成的，其中M是区域标识符，D表示双字，100是双字的起始字节。 需要注意的是，双字的起始字节（如上例中的“100”）和字一样，必须是偶数。 双字的范围为十六进制的0000～FFFFFFFF（即十进制的0～4294967295）。 在编程时要注意，如果已经用了MD100，如再用MW100或MW102要特别加以小心。 以上的字节、字和双字数据类型均为无符号数，即只有正数，没有负数。 5、16位整数（INT，Integer） 整数为有符号数，最高位为符号位，1表示负数，0表示正数。范围为－32768～32767。 6、32位整数（DINT，Double Integer） 32位整数和16位整数一样，为有符号数，最高位为符号位，1表示负数，0表示正数。 范围为－2147483648～2147483647。 7、浮点数（R，Real） 浮点数为32位，可以用来表示小数。浮点数可以为：1.m×2e ，其存储结构如图所示： 数据结构实验报告 题目：树的抽像数据类型实现 一、实验目的 对某个具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。进而达到熟练地运用本课程中的基础知识及技术的目的。 二、实验编程环境 编程环境：Visual C++。 三、实验要求 利用c语言实现树的抽象数据类型的基本操作。 四、基本操作描述 树的结构定义和树的一组基本操作： ADT Tree{ 数据对象D：D是具有相同特性的数据元素的集合。 数据关系R： 若D为空集，则称为空树； 若D仅含有一个数据元素，则R为空集，否则R={H}，H是如下二元关系： (1) 在D中存在唯一的称为根的数据元素root，它在关系H下无前驱； (2) 若D-{root}≠NULL，则存在D-{root}的一个划分D1,D2,D3,…,Dm(m>0)， 对于任意j≠k(1≤j,k≤m)有D j∩Dk=NULL,且对任意的i(1≤i≤m)，唯一存在 数据元素xi∈Di有 (3) 对应于D-{root}的划分，H-{ 【源程序】： #include Java中常用数据类型之间转换的方法 Java中几种常用的数据类型之间转换方法： 1.short-->int转换 exp:short shortvar=0; int intvar=0; shortvar=(short)intvar 2.int-->short转换 exp:short shortvar=0; int intvar=0; intvar=shortvar; 3.int->String转换 exp:int intvar=1; String stringvar; Stringvar=string.valueOf(intvar); 4.float->String转换 exp:float floatvar=9.99f; String stringvar; Stringvar=String.valueOf(floatvar); 5.double->String转换 exp double doublevar=99999999.99; String stringvar; Stringvar=String.valueOf(doublevar); 6.char->String转换 exp char charvar=’a’; String stringvar; Stringvar=String.valueOf(charvar); 7String->int、float、long、double转换Exp String intstring=”10”; String floatstring=”10.1f”; String longstring=”99999999”; String doubleString=”99999999.9”; Int I=Integer.parseInt(intstring); Float f=Integer.parseInt(floatstring); Long lo=long.parseInt(longstring); Double d=double.parseInt(doublestring); 8String->byte、short转换 数据结构实验报告 题目：二叉树抽象数据类型 学院计算机学院 专业计算机科学与技术 年级班别 学号 学生姓名 指导教师 成绩____________________ XXXXX 一．实验概要 实验项目名称: 二叉树抽象数据类型的实现 实验项目性质: 设计性实验 所属课程名称: 数据结构 实验计划学时: 6 二.实验目的 1.了解二叉树的定义以及各项基本操作。 2.实现二叉树存储、遍历及其他基本功能 三. 实验仪器设备和材料 硬件：PC机 软件：Visual C++ 6.0 四．实验的内容 1.二叉树类型定义以及各基本操作的简要描述； ADT BinaryTree { 数据对象D:D是具有相同特性的数据元素的集合. 数据关系R: 若D=?，则R=,称BinaryTree为空二叉树； 若D≠，则R={H}，H是如下二元关系： (1)在D中存在惟一的称为根的数据元素root，它在关系H下无前 驱； (2)若D-{r oot}≠?，则存在D-{root}={D1,Dr}，且D1∩Dr=?； (3)若D1≠?，则D1中存在惟一的元素x1， InitBiTree(&T); 操作结果：构造空二叉树T。 DestroyBiTree(&T); 初始条件：二叉树T存在。 操作结果：销毁二叉树T。 CreateBiTree(&T,definition); 初始条件：definition给出二叉树T的定义。 操作结果：按definition构造二叉树T。 ClearBiTree(&T); 初始条件：二叉树T存在。 操作结果：将二叉树T清为空树。 BiTreeEmpty(T); 初始条件：二叉树T存在。 操作结果：若T为空二叉树，则返回TURE,否则FALSE。BiTreeDepth(T); 初始条件：二叉树T存在。 操作结果：返回T的深度。 Root(T); 初始条件：二叉树T存在。 操作结果：返回T的根。 Value(T,e); 初始条件：二叉树T存在，e是T中的某个结点。 操作结果：返回e的值。 Assign(T,&e,value); 初始条件：二叉树T存在，e是T中的某个结点。 操作结果：结点e赋值为value。 Parent(T,e);数据库常用数据类型
Excel中常用的数据类型
数据结构串基本操作代码
常用数据类型的使用
C语言的基本数据类型及其表示
抽象数据类型线性表的定义
Java中几种常用的数据类型之间转换方法
抽象数据类型的表示与实现(实验一)
抽象数据类型
数据结构 有理数抽象数据类型
数据结构实验报告-串
基本数据类型
抽象数据类型-树
串-数据结构实验报告
JAVA中常用数据类型之间转换的方法
二叉树抽象数据类型