数据结构 第1次上机作业 相关资料
数据结构第1次上机安排
注意事项:
1.上机地点和时间：B7-238，第4(2016-03-24)、6、10、14周的星期四（第3、4节）
2. 请大家准时到上机课室。原则上第3、4节是一个连续的上机时间，即第3、4节之间无
休息时间。
3. 上机时，请认真做作业，不要聊天和玩游戏！
4. 上机作业报告提交时间: 最迟应在下周的星期六(2016-04-02)之前完成提交。
5. 上机作业报告提交方式:
请将上机作业报告电子版发送到我的QQ邮箱：
E-mail: 2582525142@https://www.360docs.net/doc/d917014730.html,
E-mail主题名称:X班XXX (上机1，作业报告)
E-mail附件名称: X班XXX(上机1，作业报告)
★由于学生众多，请各位的邮件中一定要明确说明所在班级和姓名，谢谢。
6. 上机作业报告提交的附件的内容:
要求附件只有一个word文件，其中包含以下几个方面的内容：
⑴学生班级、姓名、E-mail；
⑵作业序号、题目；
⑶完整的程序、工程截图、运行结果截图以及分析说明等。
上机目的与要求
1．掌握线性表的逻辑特征；
2．熟练掌握动态内存分配和指向它的指针变量的使用方法；
3．掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本操作；
4．熟练掌握线性表的链式存储结构定义及基本操作；
5．熟练掌握顺序表和单链表各自的插入,删除,查找, 合并,归并,遍历等算法的功能与实现，掌握线性结构信息处理的程序设计；
6．加深对顺序存储数据结构和链式存储数据结构的理解，培养解决相关实际问题的编程能力。
上机作业题目1：
仔细阅读教材中第2章的顺序表的相关内容,针对顺序表的存储结构及各个相关算法（建议参考我给的代码，见群文件）,完成与顺序表相关的软件的程序设计，并按要求完成和提交上机实验报告。
上机作业题目2：
仔细阅读教材中第2章的单链表的相关内容,针对单链表的存储结构及各个相关算法（建议参考我给的代码，见群文件）,完成与单链表相关的软件的程序设计，并按要求完成和提交上机实验报告。
下面分别是（1）顺序表和（2）单链表的一个操作实例，供大家参考。
觉得你不需要，那么请你不要参考，请见谅，特此说明！）
//（1）顺序表操作实例，仅供大家参考。
//顺序表操作【HSH】2015
#include
#include
#include
#define TRUE 1 /* 函数结果状态代码*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/
#define LISTINCREMENT 2 /* 线性表存储空间的分配增量*/
#define OVERFLOW -2
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int ElemType;
typedef struct
{
ElemType *elem; /* 存储空间基址*///动态数组首元素的地址(基址)*/
int length; /* 当前长度*/
int listsize; /* 当前动态分配的存储容量(以sizeof(ElemType)为单位) */ }SqList; //顺序表类型HSH
//////////////////////////////////
Status InitList(SqList *L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表(实际上是分配一个大小为LIST_INIT_SIZE*sizeof(ElemType)的存储空间给一个动态数组, 处理用于准备存放数据) */ (*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
/* 给动态数组分配的初始存储空间大小, 并把首元素的地址(基址)赋给elem */ if( !(*L).elem ) exit(OVERFLOW); /* 存储分配失败*/
(*L).length=0; /* 空表长度为0,是空表*/
(*L).listsize=LIST_INIT_SIZE; /*初始存储容量(本次分配允许的最大元素个数) */
return OK;
/*即if(i==1), 创建空表L成功, 实际是动态分配存储空间成功,并且用指针L指向该空表, 动态数组是用指针来表示元素位置和相应位置处元素的值的, 它没有数组名字*/
}
Status GetElem( SqList L, int i, ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值*/
if( i<1||i>L.length ) exit(ERROR);
*e=*(L.elem+i-1);
/* 因为i=1时, 起地址为: L.elem,把该地址对应的值拿出来赋给*e, 即存放在e指向的存储单元中, 供采用*/
return OK;
}
Status equal(ElemType e1, ElemType e2)
{ //比较两个数据是否相等/* 判断是否相等的函数，Union()用到*/
if (e1 == e2) return TRUE;
else return FALSE;
}
int LocateElem(SqList L, ElemType e, Status compare(ElemType, ElemType) )
{ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1, 否则为0) */ /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。*/
/* 若这样的数据元素不存在，则返回值为0。算法2.6 */
ElemType *p;
int i=1; /* i的初值为第1个元素的位序(逻辑位置) */
p=L.elem; /* p的初值为第1个元素的存储位置(存储地址) */
while( i<=L.length&&!compare(*p++, e) ) ++i;
if(i<=L.length) return i;
else return 0;
Status ListInsert(SqList *L, int i, ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在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) exit(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;
}
int ListLength(SqList *L)
{
//线性表基本操作：获取表长
if(L)
return L->length ; //等价于*L. length
else
return ERROR-1; // ERROR-1以区分ERROR为0的定义与length=0 相冲突的情况。
}
void Union(SqList *La, SqList *Lb) /* 算法2.1 */
{ /* 将所有在线性表Lb中但不在La中的数据元素插入到La中*/
ElemType e;
int La_len, Lb_len;
int i;
La_len=ListLength(La); /* 求线性表的长度*/
Lb_len=ListLength(Lb);
for(i=1; i<=Lb_len; i++)
GetElem(*Lb, i, &e); /* 取Lb中第i个数据元素赋给e */
if(!LocateElem(*La, e, equal)) /* La中不存在和e相同的元素,则插入之*/
ListInsert(La, ++La_len, e);
}
}
int visit(ElemType *p) //输出地址p处的数据
{ printf("%d\t", *p); return 1; }
Status ListTraverse(SqList *L, Status visit (ElemType *p) )
{
//线性表基本操作：表遍历
if(L){
int i;
for(i=1; i<=L->length ; i++)
(*visit)(&(L->elem[i-1]));
return OK;
}
else
return ERROR;
}
int ListLength(SqList L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数*/ return L.length;
}
/*hsh 把归并算法MergeList加入进来*/
void MergeList(SqList La,SqList Lb,SqList *Lc) /* 算法2.2 */
{ /* 已知线性表La和Lb中的数据元素按值非递减排列。*/
/* 归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列*/ int i=1,j=1,k=0;
int La_len,Lb_len;
ElemType ai,bj;
InitList(Lc); /* 创建空表Lc */
La_len=ListLength(La);
Lb_len=ListLength(Lb);
while(i<=La_len&&j<=Lb_len) /* 表La和表Lb均非空*/
{
GetElem(La,i,&ai);
GetElem(Lb,j,&bj);
if(ai<=bj)
ListInsert(Lc,++k,ai);
++i;
}
else
{
ListInsert(Lc,++k,bj);
++j;
}
}
while(i<=La_len) /* 表La非空且表Lb空*/
{
GetElem(La,i++,&ai);
ListInsert(Lc,++k,ai);
}
while(j<=Lb_len) /* 表Lb非空且表La空*/
{
GetElem(Lb,j++,&bj);
ListInsert(Lc,++k,bj);
}
}
void print(ElemType *c)
{
printf("%d ",*c);
}
Status ListTraverseM(SqList L,void(*vi)(ElemType*))
{ /* 初始条件：顺序线性表L已存在*/
/* 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败*/ /* vi()的形参加'&'，表明可通过调用vi()改变元素的值*/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(p++);
printf("\n");
return OK;
}
////////////////////////////////////////////////////////////////////////
void main()
{
SqList La,Lb,Lc;
int i;
//顺序表La：初始化
InitList(&La);
printf("请输入La的表长: ");
scanf("%d", &La.length );
//顺序表La：录入数据
if(La.length <1) printf("\n输入错误!!!\n");
else
{ printf("请输入"); printf("%d", La.length); printf("个数据给La: ");
for(i=1; i<=La.length; ++i)
scanf("%d", &La.elem[i-1]);
}
//顺序表Lb：初始化
InitList(&Lb);
printf("请输入Lb的表长: ");
scanf("%d", &Lb.length );
//顺序表Lb：录入数据
if(Lb.length <1) printf("\n输入错误!!!\n");
else
{ printf("请输入"); printf("%d", Lb.length); printf("个数据给Lb: ");
for(i=1; i<=Lb.length; ++i)
scanf("%d", &Lb.elem[i-1]);
}
//顺序表La：遍历
printf("\n顺序表La的数据是: ");
ListTraverse(&La, visit);
//顺序表Lb：遍历
printf("\n顺序表Lb的数据是: ");
ListTraverse(&Lb, visit) ;
//顺序表La：获取表长
if(ListLength (&La) >= 0) printf("\n顺序表La的长度是: %d", ListLength (&La));
else printf("\n出错!!!\n");
//顺序表Lb：获取表长
if(ListLength(&Lb) >= 0) printf("\n顺序表Lb的长度是: %d\n", ListLength (&Lb));
else printf("\n出错!!!\n");
//顺序表La和Lb：合并
Union(&La,&Lb);
//顺序表新La：遍历/* 输出新表La的内容*/
printf("\n合并之后,新的顺序表La的数据是: ");
ListTraverse(&La, visit) ;
//顺序表La：获取表长
if(ListLength (&La) >= 0) printf("\n合并之后,新的顺序表La的长度是: %d\n", ListLength (&La));
else printf("\n出错!!!\n");
printf("\n");
/*hsh 把归并算法加入进来*/
MergeList(La,Lb,&Lc);
printf("\n将合并得到的La与Lb归并之后,新的顺序表Lc的数据是: ");
printf("Lc= "); /* 输出表Lc的内容*/
ListTraverseM(Lc,print);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //（2）单链表操作实例，仅供大家参考。
//单链表操作【HSH】2015
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int ElemType;
/* c2-2.h 线性表的单链表存储结构*/
struct LNode
{
ElemType data;
struct LNode *next;
};
typedef struct LNode *LinkList; /* 另一种定义LinkList的方法*/
void visit(ElemType c) /* ListTraverse()调用的函数(类型要一致) */
{printf("%d ",c);}
Status equal(ElemType c1,ElemType c2)
{ /* 判断是否相等的函数，Union()用到*/
if(c1==c2)
return TRUE;
else
return FALSE;
}
//构造一个空表
Status InitList(LinkList *L)
{ /* 操作结果：构造一个空的线性表L */
*L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点*/ if(!*L) /* 存储分配失败*/
exit(OVERFLOW);
(*L)->next=NULL; /* 指针域为空*/
return OK;
}
//求表长
int ListLength(LinkList L)
{ /* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数*/
int i=0;
LinkList p=L->next; /* p指向第一个结点*/
while(p) /* 没到表尾*/
{i++;
p=p->next;}
return i;
}
//取元素
Status GetElem(LinkList L,int i,ElemType *e) /* 算法2.8 */
{ /* L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
int j=1; /* j为计数器*/
LinkList p=L->next; /* p指向第一个结点*/
while(p&&j {p=p->next; j++;} if(!p||j>i) /* 第i个元素不存在*/ return ERROR; *e=p->data; /* 取第i个元素*/ return OK; } //用函数判断是表L否有满足关系的元素 int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType)) { /* 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0) */ /* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。*/ /* 若这样的数据元素不存在,则返回值为0 */ int i=0; LinkList p=L->next; while(p) { i++; if(compare(p->data,e)) /* 找到这样的数据元素*/ return i; p=p->next; } return 0; } //插入 Status ListInsert(LinkList L,int i,ElemType e) /* 算法2.9。不改变L */ { /* 在带头结点的单链线性表L中第i个位置之前插入元素e */ int j=0; LinkList p=L,s; while(p&&j { p=p->next; j++; } if(!p||j>i-1) /* i小于1或者大于表长*/ return ERROR; s=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点*/ s->data=e; /* 插入L中*/ s->next=p->next; p->next=s; return OK; } //删除 Status ListDelete(LinkList L,int i,ElemType *e) /* 算法2.10。不改变L */ { /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值*/ int j=0; LinkList p=L,q; while(p->next&&j { p=p->next; j++; } if(!p->next||j>i-1) /* 删除位置不合理*/ return ERROR; q=p->next; /* 删除并释放结点*/ p->next=q->next; *e=q->data; free(q); return OK; } //遍历 Status ListTraverse(LinkList L,void(*vi)(ElemType)) /* vi的形参类型为ElemType，与bo2-1.c中相应函数的形参类型ElemType&不同*/ { /* 初始条件：线性表L已存在*/ /* 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败*/ LinkList p=L->next; while(p) { vi(p->data); p=p->next; } printf("\n"); return OK; } //逆位序建立带表头结构的单链线性表L void CreateList(LinkList *L,int n) /* 算法2.11 */ { /* 逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L */ int i; LinkList p; *L=(LinkList)malloc(sizeof(struct LNode)); (*L)->next=NULL; /* 先建立一个带头结点的单链表*/ //printf("请输入%d个数据\n",n); for(i=n;i>0;--i) {p=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点*/ scanf("%d",&p->data); /* 输入元素值*/ p->next=(*L)->next; /* 插入到表头*/ (*L)->next=p;} } //正位序建立带表头结构的单链线性表L void CreateList2(LinkList *L,int n) { /* 正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ int i; LinkList p,q; *L=(LinkList)malloc(sizeof(struct LNode)); /* 生成头结点*/ (*L)->next=NULL; q=*L; //printf("请输入%d个数据\n",n); for(i=1;i<=n;i++) {p=(LinkList)malloc(sizeof(struct LNode)); scanf("%d",&p->data); q->next=p; q=q->next;} p->next=NULL; } int main(){ int z,y,x,n=5,L_len; LinkList La,Lb; //建表并赋值 printf("1.输入\n请给单链表a的5个元素赋值（正位序）: "); CreateList2(&La,n); /* 正位序输入n个元素的值*/ printf("La="); /* 输出链表La的内容*/ ListTraverse(La,visit); printf("请给单链表b的5个元素赋值（逆位序）: "); CreateList(&Lb,n); /* 逆位序输入n个元素的值*/ printf("Lb="); /* 输出链表Lb的内容*/ ListTraverse(Lb,visit); printf("\n"); //插入 printf("2.插入\n插入单链表a的第几个元素？"); scanf("%d",&y); printf("插入的元素值为:"); scanf("%d",&x); ListInsert(La,y,x); printf("La= "); /* 输出表La的内容*/ ListTraverse(La,visit); L_len=ListLength(La); printf("此时表a长：%d\n",L_len);//输出此时表长 printf("\n"); //删除 printf("3.删除\n删除单链表a的第几个元素？"); scanf("%d",&y); ListDelete(La,y,&x); printf("删除的元素值为：%d\n",x); printf("La= "); /* 输出表La的内容*/ ListTraverse(La,visit); L_len=ListLength(La); printf("此时表a长：%d\n",L_len);//输出此时表长 printf("\n"); //查找 printf("4.查找\n查找新单链表a的哪个元素？"); scanf("%d",&z); y=LocateElem(La,z,equal); printf("所查找元素的位序为%d",y); printf("\n\n"); return 0; } //单链表操作，运行结果截图示例如下: 习题1 一、单项选择题 A1.数据结构是指（）。 A.数据元素的组织形式 B.数据类型 C.数据存储结构 D.数据定义 C2.数据在计算机存储器内表示时，物理地址与逻辑地址不相同的，称之为（）。 A.存储结构 B.逻辑结构 C.链式存储结构 D.顺序存储结构 D3.树形结构是数据元素之间存在一种（）。 A.一对一关系 B.多对多关系 C.多对一关系 D.一对多关系 B4.设语句x++的时间是单位时间，则以下语句的时间复杂度为（）。 for(i=1; i<=n; i++) for(j=i; j<=n; j++) x++; A.O(1) B.O(2n) C.O(n) D.O(3n) CA5.算法分析的目的是（1），算法分析的两个主要方面是（2）。 （1） A.找出数据结构的合理性 B.研究算法中的输入和输出关系 C.分析算法的效率以求改进 D.分析算法的易懂性和文档性 （2） A.空间复杂度和时间复杂度 B.正确性和简明性 C.可读性和文档性 D.数据复杂性和程序复杂性 6.计算机算法指的是（1），它具备输入，输出和（2）等五个特性。 （1） A.计算方法 B.排序方法 C.解决问题的有限运算序列 D.调度方法 （2） A.可行性，可移植性和可扩充性 B.可行性，确定性和有穷性 C.确定性，有穷性和稳定性 D.易读性，稳定性和安全性 7.数据在计算机内有链式和顺序两种存储方式，在存储空间使用的灵活性上，链式存储比顺序存储要（）。 A.低 B.高 C.相同 D.不好说 8.数据结构作为一门独立的课程出现是在（）年。 A.1946 B.1953 C.1964 D.1968 9.数据结构只是研究数据的逻辑结构和物理结构，这种观点（）。 A.正确 B.错误 C.前半句对，后半句错 D.前半句错，后半句对 1. 填空题 (1) 顺序栈s的数据存储在数组element中，则栈满的条件是____________,栈空的条件是。 (2) 顺序栈ｓ进行出栈操作后，要执行的语句是top____。s进行进栈操作前，要执行的语句是top______运算。 (3) 元素进入队列的一端是____________；队列出队的一端是____________。 (4)顺序队列q满的条件是，顺序队列q空的条件 是。 (5) 空串的长度等于，非空串的长度等于。 2. 选择题 (1) 串是一种特殊的线性表，其特征体现在_____。 A. 可以顺序存储 B. 数据元素是一个字符 C. 可以链接存储 D. 数据元素可以是多个字符 (2) 栈是限定在__________处进行插入或删除操作的线性表。 A. 端点 B. 栈底 C. 栈顶 D. 中间 (3) 在栈顶一端可进行的全部操作是___________。 A. 插入 B.删除 C. 插入和删除 D. 进栈 (4) 4个元素按A、B、C、D顺序连续进S栈，进行x=pop()运算后，x的值是___________, 栈顶元素的值是. A. A B. B C. C D. D (5) 栈的特点是__________。 A. 先进先出 B. 后进先出 C. 后进后出 D. 不进不出 (6) 顺序栈存储空间的实现使用___________。 A. 链表 B. 数组 C.循环链表 D. 变量 (7) 一个顺序栈一旦说明，其占用空间的大小___________。 A. 已固定 B. 可以改变 C. 不能固定 D. 动态变化 (8) 栈与一般线性表的区别主要在___________方面。 A. 元素个数 B. 元素类型 C. 逻辑结构 D. 插入、删除元素的位置 (9) 栈s经过下列运算后s.get()的值是___________, s.isEmpty( )的值是___________。 s.push(a);s.push(b);s.pop(); A. a B. b C. 1 D. 2 华农数据结构上机实验答案 数据结构上机答案 1.1顺序线性表的基本操作 #include { newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*size of(ElemType)); L.elem=newbase; L.listsize+=LISTINCREMENT; } q=&(L.elem[i-1]); for(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p; *q=e; ++L.length; return OK; } int ListDelete_Sq(SqList &L,int i,int &e) { ElemType *q,*p; if(i<1||i>L.length) return ERROR; p=&(L.elem[i-1]); e=*p; q=L.elem+L.length-1; for(++p;p<=q;p++) *(p-1)=*p; L.length--; return OK; } int main() { SqList T; int a,i; ElemType e,x; if(InitList_Sq(T)) { printf("A Sequence List Has Created.\n"); } while(1) { printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n"); scanf("%d",&a); switch(a) 国家二级ACCESS机试选择题（数据结构与算法）模拟试卷3 (总分：60.00，做题时间：90分钟) 一、选择题(总题数：30，分数：60.00) 1.在最坏情况下 （分数：2.00） A.快速排序的时间复杂度比冒泡排序的时间复杂度要小 B.快速排序的时间复杂度比希尔排序的时间复杂度要小 C.希尔排序的时间复杂度比直接插入排序的时间复杂度要小√ D.快速排序的时间复杂度与希尔排序的时间复杂度是一样的 解析：解析：按平均时间将排序分为四类：①平方阶(O(n 2 ))排序：各类简单排序，例如直接插入、直接选择和冒泡排序；②线性对数阶(O(n。log2n))排序：如快速排序、堆排序和归并排序；③O(n1+§))排序：§是介于0和1之间的常数。希尔排序便是一种；④线性阶(O(n))排序：本程序中的基数排序，此外还有桶、箱排序。 2.在深度为7的满二叉树中，度为2的结点个数为 （分数：2.00） A.64 B.63 √ C.32 D.31 解析：解析：因为在任意的二叉树中，度为O的结点(即叶子结点)总比度为2的结点的个数多1个，而度为0的结点数n 0 =2 m-1 (其中m为二叉树的深度)。本题的度为0的结点个数n 0 =2 7-1 =2 6 =64。因此，度为2的结点数n 2 =n 0 -1=63。所以选项B正确 3.设栈的顺序存储空间为S(1：m)，初始状态为top=m+1。现经过一系列入栈与退栈运算后，top=20，则当前栈中的元素个数为 （分数：2.00） A.30 B.20 C.m-19 √ D.m-20 TOP指针向上移动一位。当压入第一个元素时，TOP指针指向m+1-1=m；当压入第二个元素时，TOP指针指向 1n+1．2=m．1；…以此类推，当压入第N个元素时，TOP指针指向m+1-N=20；则N=m+1-20=m-19。因此选项C正确。 4.算法空间复杂度的度量方法是 （分数：2.00） A.算法程序的长度 B.算法所处理的数据量 C.执行算法所需要的工作单元 D.执行算法所需要的存储空间√ 解析：解析：算法空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量，因此选项D正确。 5.设循环队列为Q(1：m)，其初始状态为front=rear=m。经过一系列入队与退队运算后，front=15，rear=20。现要在该循环队列中寻找最大值的元素，最坏情况下需要比较的次数为 （分数：2.00） A.4 √ B.6 C.m-5 东北农业大学网络教育学院 数据结构作业题（一） 一、选择题（每题2分，共20分） 1．在一个长度为n的顺序表的任一位置插入一个新元素的渐进时间复杂度为（）。 A、O(n) B、O (n/2) C、O (1) D、O (n2) 2．带头结点的单链表first为空的判定条件是（）。 A、first == NULL; B、first->link == NULL; C、first->link == first; D、first != NULL; 3．在一棵树中，（）没有前驱结点。 A、分支结点 B、叶结点 C、树根结点 D、空结点 4．在有向图中每个顶点的度等于该顶点的（）。 A、入度 B、出度 C、入度与出度之和 D、入度与出度之差 5．对于长度为9的有序顺序表，若采用折半搜索，在等概率情况下搜索成功的平均搜索长度为（）的值除以9。 A、20 B、18 C、25 D、22 6．下列程序段的时间复杂度为（）。 s=0； for(i=1；i 2014年上半年数据结构（C++）第一次作业 一.单项选择题(20分) 1.已知一棵二叉树的前序遍历序列为ABCDEFG，则其中序遍历可能是____b____。 a、CABDEFG b、ABCDEFG c、DACEFBG d、ADCFEGB 2.设一个链表最常用的操作是在末尾插入结点和删除尾结点，则采用__b______存储方式最节 省时间（假设链表仅设有一个first指针一个）。 a. 单链表 b. 带头结点的双循环链表 c. 单循环链表 d. 双链表 3.有6个元素6,5,4,3,2,1顺序入栈，则所得到的输出序列不可能是___c____。 a. 5 4 3 6 1 2 b. 4 5 3 1 2 6 c. 3 4 6 5 2 1 d. 2 3 4 1 5 6 4.链表不具有的特点是__d___。 a．插入,删除不需要移动元素 b．所需空间与线性长度成正比 c．不必事先估计存储空间 d．可随机访问任一元素 5.若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂 度为_____c____。(1≤i≤n+1) a、O(0) b、O(1) c、O(n) d、O(n2) 6.对于一个头指针为head的带头结点的单链表，该表为空表的条件是__a____为真值； a. head->next==NULL; b. head==NULL; c. head->next==head; d. head!=NULL; 7.用数组A[0..N-1]存放一个循环队列，一元素出队时，其队头指针front的修改方法是 ___a____： a. front = (front + 1) mod N; b. front = (front - 2)mod N; c. front = front + 1; d. front = front – 2; 8.若用Head()和Tail()分别表示取广义表的表头和表尾，广义表A=（1,2,(3,4),(5,(6,7))），则 Head(Tail(Head(Tail(Tail(A))))) b 。 a. 1 b. 4 c. () d. （4） 9.设关于串的叙述中，哪一个是不正确的？___b_____ a. 串是字符的有限序列 b. 空串是由空格构成的串 c. 模式匹配是串的一种重要运算 d. 串既可以采用顺序存储，也可以采用链式存储 10.链下列排序算法中时间复杂度不受数据初始状态影响，恒为O(n2)的是____c____。 a.堆排序 b.起泡排序 c.直接选择排序 d.快速排序 二.填空作图题（共56分）： 1.设 n是偶数，且有程序段： for(i=1; i<=n; i++) { if(2*i <= n) { for(j = 2* i; j<=n;j++) 《数据结构实验指导书》答案 实验一： 1、请编写函数int fun(int *a, int *b),函数的功能是判断两个指针a和b所指存储单 元的值的符号是否相同；若相同函数返回1，否则返回0。这两个存储单元中的值都不为0。在主函数中输入2个整数、调用函数fun、输出结果。 #include 数fun、输出结果。 #define N 10 #include 习题二 ⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。 2.2简述线性表的两种存储结构有哪些主要优缺点及各自使用的场合。 解：顺序存储是按索引直接存储数据元素，方便灵活，效率高，但插入、删除操作将引起元素移动，降低了效率；而链式存储的元素存储采用动态分配，利用率高，但须增设表示结点之间有序关系的指针域，存取数据元素不如顺序存储方便，但结点的插入和删除十分简单。顺序存储适用于线性表中元素数量基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素的情况；而链式存储适用于频繁进行元素动态插入或删除操作的场合。 2.3 在头结点为h的单链表中，把值为b的结点s插入到值为a的结点之前，若不存在a，就把结点s插入到表尾。 Void insert(Lnode *h,int a,int b) {Lnode *p,*q,*s; s=(Lnode*)malloc(sizeof(Lnode)); s->data=b; p=h->next; while(p->data!=a&&p->next!=NULL) {q=p; p=p->next; } if (p->data==a) {q->next=s; s->next=p;} else {p->next=s; s->next=NULL; } } 2.4 设计一个算法将一个带头结点的单链表A分解成两个带头结点的单链表A和B，使A中含有原链表中序号为奇数的元素，而B中含有原链表中序号为偶数的元素，并且保持元素原有的相对顺序。 Lnode *cf(Lnode *ha) {Lnode *p,*q,*s,*hb; int t; p=ha->next; q=ha; t=0; hb=(Lnode*)malloc(sizeof(Lnode)); s=hb; while(p->next!=NULL) {if (t==0) {q=p;p=p->next;t=1;} else {q->next=p->next; p->next=s->next; s->next=p; s=p; p=p->next; t=0; } } s->next=NULL; return (hb); } 《数据结构》填空作业题答案 第 1 章绪论（已校对无误） 1．数据结构包括数据的逻辑结构、数据的存储结构和数据的运算三方面的内容。 2．程序包括两个内容：数据结构和算法。 3.数据结构的形式定义为：数据结构是一个二元组：Data Structure =（ D， S）。 4.数据的逻辑结构在计算机存储器内的表示，称为数据的存储结构。 5.数据的逻辑结构可以分类为线性结构和非线性结构两大类。 6.在图状结构中，每个结点的前驱结点数和后继结点数可以有多个。 7.在树形结构中，数据元素之间存在一对多的关系。 8.数据的物理结构，指数据元素在计算机中的标识（映象），也即存储结构。 9.数据的逻辑结构包括线性结构、树形结构和图形结构 3 种类型，树型结构和有向 图结构合称为非线性结构。 10. 顺序存储结构是把逻辑上相邻的结点存储在物理上连续的存储单元里，结点之间的逻辑 关系由存储单元位置的邻接关系来体现。 11. 链式存储结构是把逻辑上相邻的结点存储在物理上任意的存储单元里，节点之间的逻辑 关系由附加的指针域来体现。 12.数据的存储结构可用 4 种基本的存储方法表示，它们分别是顺序存储、链式存储、索引存储和散列存储。 13. 线性结构反映结点间的逻辑关系是一对一的，非线性结构反映结点间的逻辑关系是一对多或多对多。 14.数据结构在物理上可分为顺序存储结构和链式存储结构。 15. 我们把每种数据结构均视为抽象类型，它不但定义了数据的表示方式，还给出了处理数 据的实现方法。 16.数据元素可由若干个数据项组成。 17.算法分析的两个主要方面是时间复杂度和空间复杂度。 18.一个算法的时间复杂度是用该算法所消耗的时间的多少来度量的，一个算法的空间复杂 度是用该算法在运行过程中所占用的存储空间的大小来度量的。 19.算法具有如下特点：有穷性、确定性、可行性、输入、输出。 20. 对于某一类特定的问题，算法给出了解决问题的一系列操作，每一操作都有它的确切 的定义，并在有穷时间内计算出结果。 21. 下面程序段的时间复杂度为㏒ 3n 。 1 1判断题 （对）1. 数据的逻辑结构与数据元素本身的内容和形式无关。 （错）2. 线性表的逻辑顺序与物理顺序总是一致的。 （对）3. 若有一个叶子结点是二叉树中某个子树的前序遍历结果序列的最后一个结点，则它一定是该子树的中序遍历结果序列的最后一个结点。 （错）4. 对于同一组待输入的关键码集合，虽然各关键码的输入次序不同，但得到的二叉搜索树都是相同的。 （对）5. 最优二叉搜索树的任何子树都是最优二叉搜索树。 （对）6. 在二叉搜索树上插入新结点时，不必移动其它结点，仅需改动某个结点的指针，使它由空变为非空即可。 （对）7. 有n（n≥1）个顶点的有向强连通图最少有n条边。 （错）8. 连通分量是无向图中的极小连通子图。 （错）9. 二叉树中任何一个结点的度都是2。 （错）10. 单链表从任何一个结点出发，都能访问到所有结点。 二、单选题 1 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动（ B ）个元素。 A．8 B. 63.5 C. 63 D. 7 2 设有一个二维数组A[m][n]，假设A[0][0]存放位置在644（10），A[2][2]存放位置在676（10），每个元素占一个空间，则A[3][3]在（ A ）位置，（10）表明用10进数表示。 A．692（10） B. 626（10） C. 709（10） D. 724（10） 3 N个顶点的连通图至少有（ A ）条边。 A．N－1 B. N C. N＋1 D. 0 4 下面程序的时间复杂度为（ C ）。 for(int i=0; i 数据结构上机实验题目 实验一线性表的顺序存储结构 实验学时 2学时 背景知识:顺序表的插入、删除及应用。 目的要求： 1．掌握顺序存储结构的特点。 2．掌握顺序存储结构的常见算法。 实验容 1．输入一组整型元素序列，建立顺序表。 2．实现该顺序表的遍历。 3．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。4．判断该顺序表中元素是否对称,对称返回1,否则返回0。 5．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。 6．输入整型元素序列利用有序表插入算法建立一个有序表。 7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 8. 利用该顺序结构实现循环队列的入队、出队操作。 8．编写一个主函数,调试上述算法。 #include #define OVERFLOW 0 #define MAXSIZE 100 typedef int ElemType; typedef struct list {ElemType elem[MAXSIZE]; int length; }Sqlist; void Creatlist(Sqlist &L) {int i; printf("请输入顺序表的长度："); //输入一组整型元素序列，建立一个顺序表。 scanf("%d",&L.length); for(i=0;i 习题1 一、单项选择题 1.数据结构是指（）。 A.数据元素的组织形式 B.数据类型 C.数据存储结构 D.数据定义 2.数据在计算机存储器内表示时，物理地址与逻辑地址不相同的，称之为（）。 A.存储结构 B.逻辑结构 C.链式存储结构 D.顺序存储结构 3.树形结构是数据元素之间存在一种（）。 A.一对一关系 B.多对多关系 C.多对一关系 D.一对多关系 4.设语句x++的时间是单位时间，则以下语句的时间复杂度为（）。 for(i=1; i<=n; i++) for(j=i; j<=n; j++) x++; A.O(1) B.O(2n) C.O(n) D.O(3n) 5.算法分析的目的是（1），算法分析的两个主要方面是（2）。 （1） A.找出数据结构的合理性 B.研究算法中的输入和输出关系 C.分析算法的效率以求改进 D.分析算法的易懂性和文档性 （2） A.空间复杂度和时间复杂度 B.正确性和简明性 C.可读性和文档性 D.数据复杂性和程序复杂性 6.计算机算法指的是（1），它具备输入，输出和（2）等五个特性。 （1） A.计算方法 B.排序方法 C.解决问题的有限运算序列 D.调度方法 （2） A.可行性，可移植性和可扩充性 B.可行性，确定性和有穷性 C.确定性，有穷性和稳定性 D.易读性，稳定性和安全性 7.数据在计算机内有链式和顺序两种存储方式，在存储空间使用的灵活性上，链式存储比顺序存储要（）。 A.低 B.高 C.相同 D.不好说 8.数据结构作为一门独立的课程出现是在（）年。 A.1946 B.1953 C.1964 D.1968 9.数据结构只是研究数据的逻辑结构和物理结构，这种观点（）。 A.正确 B.错误 C.前半句对，后半句错 D.前半句错，后半句对 实习一： 1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。 2、设有一个单位的人员工资有如下信息：name、department、 base pay、allowance、total。现从键盘输入一组人员工资数据并将它们存储到名为paydata的文件中；再从paydata取出工资数据并给每个人的base pay增加100元，增加后将工资数据显示于屏幕(每行1人)。请编写能够完成上述工作的程序。 代码如下： 1.#include 注意事项1. 考试时间2小时，13：00-15：00 2. 题目4选2 3. 所有题目均使用标准输入和标准输出3. 只提交源程序，文件后缀名只能是.C或.CPP 4. 源文件大小不能超过10K，否则会被当作恶意提交而扣分5. 严格按照题目要求输出，去掉不需要的提示信息或调试信息6. 在程序中不要使用fflush(stdin)函数，否则会导致结果错误另外注意：本次是模拟测试，上机时间是4个小时，我们考试时间从14点开始到17点30分结束。同学视自己的能力，能做几道做几道。 哈夫曼树 时间限制: 100 second 内存限制: 100 Kb 描述 构造哈夫曼树（最优二叉树） 输入 输入n个结点每个结点的权值 输出 构造哈夫曼树（是最优二叉树）得到每个结点的哈夫曼编码 输入样例 23 186 64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 输出样例 1( 186):00 2( 64):1001 3( 13):101100 4( 22):110010 5( 32):11100 6( 103):011 7( 21):110001 8( 15):101101 9( 47):11010 10( 57):0101 11( 1):101111000 12( 5):10111101 13( 32):11101 14( 20):110000 15( 57):1010 16( 63):1000 17( 15):101110 18( 1):101111001 19( 48):11011 20( 51):0100 21( 80):1111 22( 23):110011 23( 8):1011111 提示 输入第一行是结点数23 第二行是这几个结点的权值输出格式为结点号（权值）：哈夫曼编码 1．数据的最小单位是（ A ）。 (A) 数据项(B) 数据类型(C) 数据元素(D) 数据变量 2．下面关于线性表的叙述错误的是（D）。 (A) 线性表采用顺序存储必须占用一片连续的存储空间 (B) 线性表采用链式存储不必占用一片连续的存储空间 (C) 线性表采用链式存储便于插入和删除操作的实现 (D) 线性表采用顺序存储便于插入和删除操作的实现 3．设顺序循环队列Q[0：M-1]的头指针和尾指针分别为F和R，头指针F总是指向队头元素的前一位置，尾指针R总是指向队尾元素的当前位置，则该循环队列中的元素个数为（C）。 (A) R-F (B) F-R (C) (R-F+M)％M (D) (F-R+M)％M 4．设某棵二叉树的中序遍历序列为ABCD，前序遍历序列为CABD，则后序遍历该二叉树得到序列为（A）。 (A) BADC(B)BCDA (C) CDAB (D) CBDA 5．设某棵二叉树中有2000个结点，则该二叉树的最小高度为（C）。 (A) 9 (B) 10 (C) 11(D) 12 6．下面程序的时间复杂为（B） for（i=1，s=0；i<=n；i++）{t=1；for(j=1；j<=i；j++) t=t*j；s=s+t；} (A) O(n) (B) O(n2)(C) O(n3) (D) O(n4) 7．设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（C）。 (A) q=p->next；p->data=q->data；p->next=q->next；free(q)； (B) q=p->next；q->data=p->data；p->next=q->next；free(q)； (C) q=p->next；p->next=q->next；free(q)； (D) q=p->next；p->data=q->data；free(q)； 8．设一维数组中有n个数组元素，则读取第i个数组元素的平均时间复杂度为（C ）。 (A)O(n) (B) O(nlog2n) (C) O(1)(D) O(n2) 9．设一棵二叉树的深度为k，则该二叉树中最多有（D ）个结点。 (A) 2k-1 (B) 2k(C) 2k-1(D) 2k-1 10．设用链表作为栈的存储结构则退栈操作（ B ）。 (A) 必须判别栈是否为满(B) 必须判别栈是否为空 (C) 判别栈元素的类型(D) 对栈不作任何判别 11．函数substr(“DATASTRUCTURE”，5，9)的返回值为（A ）。 (A) “STRUCTURE”(B) “DATA” (C) “ASTRUCTUR”(D) “DATASTRUCTURE” 12．设某二叉树中度数为0的结点数为N0，度数为1的结点数为N l，度数为2的结点数为N2，则下列等式成立的是（ C）。 (A) N0=N1+1 (B) N0=N l+N2(C) N0=N2+1(D) N0=2N1+l 13．设二叉树的先序遍历序列和后序遍历序列正好相反，则该二叉树满足的条件是（B ）。 (A) 空或只有一个结点(B) 高度等于其结点数 (C) 任一结点无左孩子(D) 任一结点无右孩子 14. 深度为k的完全二叉树中最少有（ B ）个结点。 (A) 2k-1-1 (B) 2k-1(C) 2k-1+1(D) 2k-1 《数据结构》形成性考核册第1次作业参考答案第一章绪论 一、填空题 1、数据操作 2、集合结构线性结构 树型结构图形结构 3、引用类型 4、1：1 1：n n：m 5、不对 6、多个 7、O（m*n） 8、时间复杂度 空间复杂度 9、顺序链接索引散列 10、O（n2） 11、O（n） 12、O（n）O（m*n） 二、选择题1~8：DBABADDD 三、应用题 （1）功能：判断n是否是一个素数，若是则返回数值1，否则返回0。时间复杂度：O（n）。 （2）功能：计算S=1！+2！+…+n!的值。时间复杂度：O（n）。 （3）功能：计算S=1！+2！+…+n!的值。时间复杂度：O（n2）。 （4）求出满足不等式1+2+…+i≥n的最小i值。O（n）。 第二章线性表 四、填空题 1、A[P-1] 2、108 3、前驱后继 4、最后一个表头 5、p->next=q->next q->next=p 6、HL->next=NULL HL->next=HL 7、P->next 8、Q->next 9、P->next s 10、从前向后前移n-i 11、O（1）O（n） 12、（n+1）/2 13、O（n）O（1） 14、A[P].next 15、a[j].next=a[i].next a[i].next=j 16、数据值指针 五、选择题1~5：BDDBC 六、应用题 1、（1）、（79，62，34，57，26，48）（2）、（26，34，48，57，62，79）（3）、（48，56，57，62，79，34）（4）、（56，57，79，34） （5）、（26，34，39，48，57，62） 2、（1）将类型为List的线性表L中第i个元素移至表尾位置的算法，L中的元素类型为ElemType，假定不需要对i的值进行有效性检查。 void move (List& L, int i) { ElemType x=L.list[ i-1]; for(int j=i; j 数据结构上机考试试题（C++语言版） 考试要求：本次考试共列考核试题4大题，考生可以在所列4个考核试题中任选3个小题（即可能只属于2个大题），作为上机考核试题。 考核原则：所选题目在上机编程调试通过后即为考核通过。监考教师依据学生编程及调试通过与否情况给予考核成绩。 考核成绩评分标准： 所选3个题目全部编写出程序并调试通过：优 所选3个题目全部编写出程序，但只有2个上机调试通过：良 所选3个题目全部编写出程序，但只有1个上机调试通过：及格 所选3个题目全部编写出程序但都没有上机调试通过，或没有编写出全部程序：不及格。考核时间：2小时。 考核试题： 1、建立一个顺序方式存储的线性表，向表中输入若干元素后进行以下操作： （1）向线性表的表头、表尾或合适位置插入元素 （2）对线性表按升序或降序输出 2、建立一个动态链接方式存储的线性表，向表中输入若干元素后进行以下操作： （1）从单链表中查找指定元素 （2）返回单链表中指定序号的结点值 3、建立一个动态链接结构存储的二叉树，向这棵二叉树进行以下操作： （1）按任中序遍历次序输出二叉树中的所有结点 （2）求二叉树的叶子数 4、编写一个对整型数组A[n+1]中的A[1]至A[n]元素进行选择排序的算法，使得首先从待排序区间中选择出一个最大值并同最后一个元素交换，再从待排序区间中选择出一个最小值并同最第一个元素交换，反复进行直到待排序区间中元素的个数不超过1为止。 #include<> #include<> #include"" //初始化线性表 void InitList(LinearList& L, int ms) { =new ElemType[ms]; if(! { cerr<<"Memory allocation failure!"< 第 1 章绪论 课后习题讲解 1. 填空 ⑴（）是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 【解答】数据元素 ⑵（）是数据的最小单位，（）是讨论数据结构时涉及的最小数据单位。 【解答】数据项，数据元素 【分析】数据结构指的是数据元素以及数据元素之间的关系。 ⑶从逻辑关系上讲，数据结构主要分为（）、（）、（）和（）。 【解答】集合，线性结构，树结构，图结构 ⑷数据的存储结构主要有（）和（）两种基本方法，不论哪种存储结构，都要存储两方面的内容：（）和（）。 【解答】顺序存储结构，链接存储结构，数据元素，数据元素之间的关系 ⑸算法具有五个特性，分别是（）、（）、（）、（）、（）。 【解答】有零个或多个输入，有一个或多个输出，有穷性，确定性，可行性 ⑹算法的描述方法通常有（）、（）、（）和（）四种，其中，（）被称为算法语言。 【解答】自然语言，程序设计语言，流程图，伪代码，伪代码 ⑺在一般情况下，一个算法的时间复杂度是（）的函数。 【解答】问题规模 ⑻设待处理问题的规模为n，若一个算法的时间复杂度为一个常数，则表示成数量级的形式为（），若为n*log25n，则表示成数量级的形式为（）。 【解答】Ο(1)，Ο(nlog2n) 【分析】用大O记号表示算法的时间复杂度，需要将低次幂去掉，将最高次幂的系数去掉。 2. 选择题 ⑴顺序存储结构中数据元素之间的逻辑关系是由（）表示的，链接存储结构中的数据元素之间的逻辑关系是由（）表示的。 A 线性结构 B 非线性结构 C 存储位置 D 指针 【解答】C，D 【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素，其逻辑关系由存储位置（即元素在数组中的下标）表示；链接存储结构中一个数据元素对应链表中的一个结点，元素之间的逻辑关系由结点中的指针表示。 第一章 单选题 1、下列关于算法的基本特征，说法不正确的是（）。能行性是算法中的每一个步骤必须能够实现且能达到预期的目的。算法的确定性是指算法中的每一个步骤必须是有明确的定义，不允许模棱两可。 算法的有穷性是指算法必须能在有限的时间内做完。算法与提供情报无关。 [D] 教师批改：D 2、算法的时间复杂度取决于（）。问题的规模待处理的数据的初态 问题的难度 A 和B [D] 教师批改：D 3、下列选项中，不是算法基本特征的是（）。可行性有穷性 确定性高效率 [D] 教师批改：D 4、通常一个好的算法应达到的目标中，不包括（）。正确性可读性 技巧性健壮性 [C] 教师批改：C 5、在一般的计算机系统中，基本的运算和操作不包括（）。语法处理算术运算 关系运算数据传输 [A] 教师批改：A 6、工程上常用的分治法是（）。列举法归纳法 减半递推技术回溯法 [C] 教师批改：C 多选题 7、算法设计的要求包括（）。 正确性可读性 健壮性唯一性 [ABC] 教师批改：A，B，C 8、算法的时间复杂度应该与（）无关。 所使用的计算机程序设计语言 基本运算的执行次数程序编制者 [ABD] 教师批改：A，B，D 9、下列关于算法的描述中，不正确的有（）。 算法即是计算机程序算法是解决问题的计算方法 算法是排序方法算法是解决问题的有限运算序列 [ABC] 教师批改：A，B，C 填空题 16、所谓算法是指（）。 教师批改：解题方案的准确而完整的描述 17、算法的基本特征有（）、（）、（）和（） 教师批改：能行性、确定性、有穷性和拥有足够的情报。 18、一个算法通常由两种基本要素组成，它们是（）和（）。 教师批改：算法中对数据的运算和操作。 算法的控制结构。 19、工程上常用的几种算法设计方法有列举法、（）、（）、（）、（）和回溯法。 教师批改：归纳法、递推、递归、减半递推技术。 20、算法的复杂度主要包括（）复杂度和（）复杂度。 教师批改：时间、空间 综合题 21、设给定3个整数a，b，c，试写出寻找这3个整数的中数的算法；并分析在平均情况与最坏情况下，该算法分别要做多少次比较？ 寻找这3个整数的中数的算法用C语言描述如下（中数m由函数值返回）： int mid ( int a, int b, int c) { int m 。m=a 。 if ( m>=b ) { if (m>=c) { if ( b>=c ) m=b 。else m=c 。} } else { if ( m<=c) { if (b>=c) m=c。else m=b 。} } return ( m ) 。 } 假设a，b，c中的每一个数为中数的概率相等（均为1/3）。由于当a为中数时需要比较2次，b或c为中数时均需要比较3次，因此，在平均情况下上述算法所需要的比较次数为 2*（1/3）+3*（1/3）+3*（1/3）= 8/3 即在平均情况下，上述算法需要比较8/3次。 在最坏情况下，上述算法需要比较3次（当b或c为中数时）。 第二章 选择题 1、下列排序方法中，哪一个是稳定的排序方法（）。归并排序稀尔排序 堆排序快速排序 [A] 教师批改：A 2、设输入序列为1，2，3，4，借助一个栈得到的输出序列可以是（）。3，4，1，2 4，2，1，3 4，1，2，3 1，3，4，2 [D] 教师批改：D 3、用数组A[m]存放循环队列的元素值，若其头尾指针分别为front和rear，则循环队列中当前元素的个数为（）。(rear+front)%m (rear-front+m)%m (rear-front)%m (rear-front+1)%m [D] 教师批改：B 4、对于下三角矩阵A，若采用一个一维数组B以行为主顺序存放压缩矩阵A，则A43存放在（）中. B7 B8 B9 B10 [C] 教师批改：C 5、深度为5的二叉树至多有（）个结点。16 32数据结构习题及参考答案
数据结构第3次作业
华农数据结构上机实验答案
国家二级ACCESS机试选择题(数据结构与算法)模拟试卷3
数据结构作业题及参考答案
2017年上半年数据结构(C++)第一次作业
数据结构上机实验答案
数据结构上机例题及答案
《数据结构》填空作业题(答案)
华工平时作业数据结构第一次作业
经典数据结构上机题_答案解析
数据结构习题及参考答案 .
数据结构上机答案(c语言版)
数据结构上机考试题
数据结构作业(附答案)
数据结构形成性考核册第1次作业参考答案
数据结构上机考试试题
数据结构习题与答案
数据结构作业标准答案