四川大学网络教育《数据结构》第二次作业答案

合集下载

数据结构第二次作业

// 数据结构第二次作业.cpp : 定义控制台应用程序的入口点。

//#include<iostream>using namespace std;const int Stacksize = 50; //定义栈的最大高度template <class T>class SeqStack//定义共享栈模板类{public:SeqStack(){ top1 = -1, top2 = Stacksize; }; //有参构造函数void push1(T x);void push2(T x);T Pop1();T Pop2();T GetTop1();T GetTop2();bool Empty1(){return(NULL == top1) ? true : false;}bool Empty2(){return(Stacksize == top2) ? true : false;}private:T data1[Stacksize]; //定义数组T data2[Stacksize];int top1, top2; //共享栈指针};template<class T>void SeqStack<T>::push1(T x){//if (top1 >= Stacksize - 1)throw"上溢";cout << "push1:";top1++;data1[top1] = x;cout << data1[top1] << endl;}template<class T>void SeqStack<T>::push2(T x){//if (top2 <= 0)throw"上溢";cout << "push2:";top2--;data2[top2] = x;cout << data2[top2] << endl;}template<class T>T SeqStack<T>::Pop1(){//if (Empty1())throw"下溢";cout << "pop1:" << data1[top1] << endl;top1--;return data1[top1 + 1];}template<class T>T SeqStack<T>::Pop2(){//if (Empty2())throw"下溢";cout << "pop2:" << data2[top2] << endl;top2++;return data2[top2 - 1];}template<class T>T SeqStack<T>::GetTop1(){//if (Empty1())throw"下溢";cout << "GetTop1:" << data1[top1] << endl;return data1[top1];}template<class T>T SeqStack<T>::GetTop2(){//if (Empty2())throw"下溢";cout << "GetTop2:" << data2[top2] << endl;return data2[top2];}template<class T> //栈的链式存储结构struct Node{T date;struct Node<T>*next;};template<class T>class LinkStack//定义链栈模板类{public:LinkStack(T a[], int n);~LinkStack();//void Output(int n);void Push(T x);T Pop();T GetTop();bool Empoty(){ return(NULL == top) ? true : false; } private:struct Node<T>*top;};template<class T>LinkStack<T>::LinkStack(T a[], int n){Node<T>*front = new Node<T>;Node<T>*r = front;for (int i = 0; i < n; i++){Node<T>*s = new Node<T>;s->date= a[i];r->next = s;r = s;}r->next = NULL;}template<class T>void LinkStack<T>::Push(T x){Node<T>*p = new Node<T>;p->date = x;cout << "Push:" << p->date << endl;p->next = top;top = p;}template<class T>T LinkStack<T>::Pop(){//if (Empoty())throw"下溢";T x = top->date;Node<T>*p = top;top = top->next;cout << "Pop:" << x << endl;delete p;return x;}template<class T>LinkStack<T>::~LinkStack(){while (top){Node<T>*p = top;top = top->next;delete p;}}const int QueueSize = 100;template<class T>class CircleQueue//循环队列模板类{public:CircleQueue(){ front = rear = 0; }void EnQueue(T x);//void Output(int n);T DeQueue();T GetFront();int GetLength();bool Empty(){ return front == rear ? true; false; }private:T date[QueueSize];int front;int rear;};template<class T>void CircleQueue<T>::EnQueue(T x){if ((rear + 1) % QueueSize == front)throw"上溢";rear = (rear + 1) % QueueSize;date[rear]=x;cout << "EnQueue:" << date[rear] << endl;}template<class T>T CircleQueue<T>::DeQueue(){if (rear == front)throw"上溢";front = (front + 1) % QueueSize;cout << "DeQueue:" << date[front] << endl;return date[front];}template<class T>T CircleQueue<T>::GetFront(){//if (rear == front)throw"上溢";cout << "GetFront:" << date[(front + 1) % QueueSize] << endl;return date[(front + 1) % QueueSize];}template<class T>int CircleQueue<T>::GetLength(){cout << "Length:" << (rear - front + QueueSize) % QueueSize << endl;return(rear - front + QueueSize) % QueueSize;}template<class T>class LinkQueue//链队列模板类{public:LinkQueue(){front = rear = new Node<T>;front->next = NULL;}~LinkQueue();void EnQueue(T x);T DeQueue();T GetFront();bool Empoty(){ return front == rear ? true; false; } private:Node<T>*front;Node<T>*rear;};template<class T>void LinkQueue<T>::EnQueue(T x){rear->next = new Node<T>;rear = rear->next;rear->date = x;cout << "EnQueue:" << rear->date << endl;rear->next = NULL;}template<class T>T LinkQueue<T>::DeQueue(){Node<T>*p = front->next;front->next = p->next;T x = p->date;cout << "DeQueue:" << x << endl;delete p;if (!(front->next))rear = front;return x;}template<class T>T LinkQueue<T>::GetFront(){//if (!(front->next))throw"上溢";cout << "GetFront:" << front->next->date << endl;return front->next->date;}template<class T>LinkQueue<T>::~LinkQueue(){while (front){rear = front->next;delete front;front = rear;}}void main(){cout << "共享栈功能实现" << endl;/*int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int b[] = { 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };int n = 10;*/SeqStack<int> Seq;//Seq.Output(n);Seq.push1(33);Seq.GetTop1();Seq.Pop1();Seq.push2(44);Seq.GetTop2();Seq.Pop2();cout << "链式栈功能的实现" << endl;int c[] = { 1, 2, 3 };int m = 3;LinkStack<int> Lin(c, m);Lin.Push(10);Lin.Pop();cout << "循环队列功能的实现" << endl;CircleQueue<int> Cir;Cir.EnQueue(100);Cir.GetFront();Cir.DeQueue();Cir.GetLength();cout << "链队列功能的实现" << endl;LinkQueue<int> Que;Que.EnQueue(50);Que.GetFront();Que.DeQueue();system("pause");}#include<iostream>using namespace std;typedef struct node{struct node *lchild;struct node *rchild;char data;}BiTreeNode, *BiTree;void createBiTree(BiTree &T){char c;cin >> c;if ('#' == c)T = NULL;else{T = new BiTreeNode;T->data = c;createBiTree(T->lchild);createBiTree(T->rchild);}}//递归前序遍历二叉树bool PreOrder(BiTree &T) {if (T != NULL) {cout << T->data << " ";PreOrder(T->lchild);PreOrder(T->rchild);}return true;}//递归中序遍历二叉树bool InOrder(BiTree &T) {if (T != NULL) {InOrder(T->lchild);cout << T->data << " ";InOrder(T->rchild);}return true;}//递归后序遍历二叉树bool PostOrder(BiTree &T){if (T != NULL) {PostOrder(T->lchild);PostOrder(T->rchild);cout << T->data << " ";}return true;}bool LevelOrder(BiTree* T){queue<int> q;q.push(1);q.push(2);q.push(3);q.push(4);cout << (int)q.front() << endl;q.pop();cout << (int)q.front() << endl;q.pop();cout << (int)q.front() << endl;q.pop();cout << (int)q.front() << endl; #elsequeue<BiTNode*> q;//节点队列BiTNode* node;if (T != NULL){//不是空树q.push(T);}else{return false;}while (!q.empty()){node = (BiTNode*)q.front();//队首节点q.pop();//队首节点出队Visit(node);if (node->lchild != NULL){q.push(node->lchild);}if (node->rchild != NULL){q.push(node->rchild);}}#endifreturn true;}void main(){BiTree T;createBiTree(T);//构建二叉树cout << T->lchild->data << endl;cout << T->lchild->lchild->data << endl;cout << T->lchild->rchild->data << endl;cout << "*********递归先序遍历**********" << endl;PreOrder(T);cout << endl << "*********递归中序遍历**********" << endl;InOrder(T);cout << endl << "*********递归后序遍历**********" << endl;PostOrder(T);cout << endl << "********层序遍历**********" << endl;LevelOrderTraverse(T);}。

四川大学网络教育《数字电子技术》第二次作业

2020/10/15
2020/10/15
B. 高速度
C. 微四进制计数器 B. 同步六进制计数器 C. 同步八进制计数器 D. 同步五进制计数器
8. 对于T触发器，若原态Qn=0，欲使新态Qn+1=1，应使输入T（）。 A. 0 B. 1 C. Q
D.
9. A. 0 B. 1 C. Q
D. 2位二进制同步可逆计数器
20. A. 8进制计数器 B. 7进制计数器 C. 6进制计数器 D. 5进制计数器
三、判断题。本大题共15个小题，每小题 2.0 分，共30.0分。
1. 在二进制与十六进制的转换中，有下列关系（1001110111110001）B=（9DF1）H。 2. 8421BCD码即为8421码。 3. TTL与非门采用复合管作输出级的负载电阻，可提高TTL与非门的带负载能力。 4. n变量的逻辑函数其全部最小项有n个。 5. 门电路具有多个输入端和多个输出端。 6. OC与非门的输出端可以并联运行，实现“线与”关系，即L=L1•L2。 7. 译码器是一种多路输入、多路输出的逻辑部件。
13. 一个无符号8位数字量输入的DAC，其分辨率为（）位。
A. 1 B. 3 C. 4
D. 8 14. 十进制数25用8421BCD码表示为（
）。
A. 10 101
B. 0010 0101 C. 100101 D. 10101
15. 与八进制数(47.3)8等值的数为（）。
A. (100111.011)2 B. (27.8)16 C. (27.3 )16 D. (100111.11)2
1. A. B. C. D.
2. A. A B. C. A+B D.
3.
A.

(精华版)国家开放大学电大《数据结构》网络课形考网考作业及答案

(精华版)国家开放大学电大《数据结构》网络课形考网考作业及答案(精华版)国家开放大学电大《数据结构》网络课形考网考作业及答案100%通过考试说明：2022年秋期电大把该网络课纳入到“国开平台”进行考核，该课程共有4个形考任务，针对该门课程，本人汇总了该科所有的题，形成一个完整的标准题库，并且以后会不断更新，对考生的复习、作业和考试起着非常重要的作用，会给您节省大量的时间。

做考题时，利用本文档中的查找工具，把考题中的关键字输到查找工具的查找内容框内，就可迅速查找到该题答案。

本文库还有其他网核及教学考一体化答案，敬请查看。

课程总成绩=形成性考核×50%+终结性考试×50%形考任务1一、单项选择题（每小题3分，共60分）题目1把数据存储到计算机中，并具体体现数据元素间的逻辑结构称为（）。

选择一项： D.物理结构题目2下列说法中，不正确的是（）。

选择一项： C.数据项可由若干个数据元素构成题目3一个存储结点存储一个（）。

选择一项： C.数据元素题目4数据结构中，与所使用的计算机无关的是数据的（）。

选择一项： C.逻辑结构题目5在线性表的顺序结构中，以下说法正确的是（）。

选择一项： D.逻辑上相邻的元素在物理位置上也相邻题目6对链表,以下叙述中正确的是（）。

选择一项： C.不能随机访问任一结点题目7下列的叙述中，不属于算法特性的是（）。

选择一项： C.可读性题目8算法的时间复杂度与（）有关。

选择一项： D.算法本身题目9设有一个长度为n的顺序表，要在第i个元素之前（也就是插入元素作为新表的第i个元素），插入一个元素，则移动元素个数为（）。

选择一项： C.n-i+1题目10设有一个长度为n的顺序表，要删除第i个元素移动元素的个数为（）。

选择一项： C.n-i题目11在一个单链表中，p、q分别指向表中两个相邻的结点，且q所指结点是p所指结点的直接后继，现要删除q所指结点，可用语句（）。

选择一项： A.p->next=q->next题目12在一个单链表中p所指结点之后插入一个s所指的结点时，可执行（）。

四川大学网络学院-数据结构课程设计-参考答案

四川大学《数据结构》课程设计实验项目及内容提要(实验任选一个完成)
试读3页
数据结构实验报告
实验名称： Huffman编码(二叉树应用)
提交文档学生姓名：
提交文档学生学号：
同组成员名单：无
指导教师姓名：
指导教师评阅成绩：
指导教师评阅意见：
.
.
提交报告时间： 2020 年 3 月 26 日
目录
一、概述 (1)
二、系统分析 (1)
三、概要设计 (2)
四、详细设计 (4)
4.1 赫夫曼树的建立 (4)
4.1.1 选择选择parent 为0 且权值最小的两个根结点的算
法 (5)
4.1.2 统计字符串中字符的种类以及各类字符的个数 (7)
4.1.3构造赫夫曼树 (8)
4.2赫夫曼编码 (10)
4.2.1赫夫曼编码算法 (10)
4.2.2建立正文的编码文件 (11)
4.3代码文件的译码 (12)
五、运行与测试 (14)
六、总结与心得 (14)
参考文献................................. 错误!未定义书签。

附录..................................... 错误!未定义书签。

《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)

第1章4．答案：（1）顺序存储结构顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。

（2）链式存储结构顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。

但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。

所以链式存储结构通常借助于程序设计语言的指针类型来描述。

5. 选择题(1)~(6)：CCBDDA\6．（1）O(1) （2）O(m*n) （3）O(n2)（4）O(log3n) （5）O(n2) （6）O(n)（第2章1．选择题（1）~（5）：BABAD （6）~（10）： BCABD （11）~（15）：CDDAC\2．算法设计题（1）将两个递增的有序链表合并为一个递增的有序链表。

要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。

表中不允许有重复的数据。

[题目分析]合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。

如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。

当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。

void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){法设计题（1）将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。

当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。

两个栈均从两端向中间增长。

试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。

《数据结构》四川大学_期终复习试题+答案

四川大学“精品课程”计算机科学与技术专业（本科）《数据结构与算法分析》课程考试说明与模拟试卷第一部分考试说明数据结构与算法分析》是计算机科学与技术专业统设的一门重要的必修专业基础课，它主要研究数据的各种逻辑结构和在计算机中的存储结构，还研究对数据进行的插入、查找、删除、排序、遍历等基本运算或操作以及这些运算在各种存储结构上具体实现的算法。

由于本课程的主教材采用C++语言描述算法，期末卷面考试也采用C++语言描述，因而要求在做平时作业和上机实验操作时用C++开发工具（如：Visual C++或C++ Builder或Borland C++）。

下面按照主教材中各章次序给出每章的具体复习要求，以便同学们更好地进行期末复习。

第一章绪论重点掌握的内容：1. 数据结构的二元组表示，对应的图形表示，序偶和边之间的对应关系。

2. 集合结构、线性结构、树结构和图结构的特点。

3. 抽象数据类型的定义和表示方法。

4. 一维和二维数组中元素的按下标和按地址的访问方式以及相互转换，元素地址和数组地址的计算，元素占用存储空间大小和数组占用存储空间大小的计算。

5. 普通函数重载和操作符函数重载的含义，定义格式和调用格式。

6. 函数定义中值参数和引用参数的说明格式及作用，函数被调用执行时对传送来的实际参数的影响。

7. 算法的时间复杂度和空间复杂度的概念，计算方法，数量级表示。

8. 一个简单算法的最好、最差和平均这三种情况的时间复杂度的计算。

对于本章的其余内容均作一般掌握。

第二章线性表重点掌握的内容：1. 线性表的定义及判别和抽象数据类型的描述，线性表中每一种操作的功能，对应的函数名、返回值类型和参数表中每个参数的作用。

2. 线性表的顺序存储结构的类型定义，即List类型的定义和每个域的定义及作用。

3. 线性表的每一种运算在顺序存储结构上实现的算法，及相应的时间复杂度。

4.链接存储的概念，线性表的单链接和双链接存储的结构，向单链表中一个结点之后插入新结点或从单链表中删除一个结点的后继结点的指针链接过程。

数据结构第二章作业及答案

8
解答(续):
(2) 插入操作基本步骤: 1) 若i不合法或表L已满，算法结束并返回 ERROR；否则转2) 2) 将第i个元素及之后的所有元素均后移一个位置 3) 将新元素写入空出的位置； 4) 表长+1
9
解答(续):
插入操作算法(算法2.4 )：
Status ListInsert_Sq(SqList &L, int i , ElemType e) { //在顺序线性表L中第i个位置之前插入新的元素e, // i的合法值为1≤i≤ListLength_Sq(L)+1 if (i<1||i>L.length+1)return ERROR; //i值不合法 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; }//ListInsert_Sq
15
4．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。 A．顺序表 B．双向链表 C．带头结点的双向循环链表 1 D．循环链表

《数据结构》教材课后习题+答案

《数据结构》教材课后习题+答案数据结构第一章介绍数据结构是计算机科学中重要的概念，它涉及到组织和存储数据的方法和技术。

数据结构的选择对于算法的效率有着重要的影响。

本教材为读者提供了丰富的课后习题，以帮助读者巩固所学知识并提高解决问题的能力。

下面是一些选定的习题及其答案，供读者参考。

第二章线性表习题一：给定一个顺序表L，编写一个算法，实现将其中元素逆置的功能。

答案一：算法思路：1. 初始化两个指针i和j，分别指向线性表L的首尾两个元素2. 对于L中的每一个元素，通过交换i和j所指向的元素，将元素逆置3. 当i>=j时，停止逆置算法实现：```pythondef reverse_list(L):i, j = 0, len(L)-1while i < j:L[i], L[j] = L[j], L[i]i += 1j -= 1```习题二：给定两个线性表A和B，编写一个算法，将线性表B中的元素按顺序插入到线性表A中。

答案二：算法思路：1. 遍历线性表B中的每一个元素2. 将B中的元素依次插入到A的末尾算法实现：```pythondef merge_lists(A, B):for element in B:A.append(element)```第三章栈和队列习题一：编写一个算法，判断一个表达式中的括号是否匹配。

表达式中的括号包括小括号"()"、中括号"[]"和大括号"{}"。

答案一：算法思路：1. 遍历表达式中的每一个字符2. 当遇到左括号时，将其推入栈中3. 当遇到右括号时，判断栈顶元素是否与其匹配4. 当遇到其他字符时，继续遍历下一个字符5. 最后判断栈是否为空，若为空则表示括号匹配算法实现：```pythondef is_matching(expression):stack = []for char in expression:if char in "([{":stack.append(char)elif char in ")]}":if not stack:return Falseelif (char == ")" and stack[-1] == "(") or (char == "]" and stack[-1] == "[") or (char == "}" and stack[-1] == "{"):stack.pop()else:return Falsereturn not stack```习题二：利用两个栈实现一个队列。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

首页 - 我的作业列表 - 《数据结构》第二次作业答案
欢迎你，
你的得分： 76.0
完成日期：2014年01月09日 18点12分

说明：每道小题括号里的答案是您最高分那次所选的答案，标准答案将在本次作业结束
(即2014年03月13日)后显示在题目旁边。

一、单项选择题。本大题共25个小题，每小题 2.0 分，共50.0分。在每小题给出的选
项中，只有一项是符合题目要求的。

若有序表为（b, c, d, e, f, g, q, r, s, t），则在二分查找关键字b的过程中，先后进行比
较的关键字依次为（）。
 ( A )
f,c,b
f,d,b
g,c,b
g,d,b
在对n个关键字进行直接选择排序的过程中，每一趟都要从无序区选出最小关键字元素，
则在进行第i趟排序之前，无序区中元素的个数为（）。

 ( D )
i
i+1
n-i
n-i+1
若用邻接矩阵表示一个有向图，则其中每一列包含的″1″的个数为（）。

 ( A )
图中每个顶点的入度
图中每个顶点的出度

图中每个顶点的度
图中连通分量的数目

一散列表长度m为100，采用除留余数法构造散列函数，即H(K)=K%P (P<=m),，为使
散列函数具有较好的性能，P的选择应是（）。

 ( D )
99
100
97
93
二维数组A[8][9]按行优先顺序存储，若数组元素A[2][3]的存储地址为1087，A[4][7]
的存储地址为1153，则数组元素A[6][7]的存储地址为（）。
 ( A )

1207
1209
1211
1213

对关键字序列(56, 23, 78, 92, 88, 67, 19, 34)进行增量为3的一趟希尔排序的结果为（）。

 ( D )
(19, 23, 56, 34, 78, 67, 88, 92) )
(23, 56, 78, 66, 88, 92, 19, 34)

(19, 23, 34, 56, 67, 78, 88, 92)
(19, 23, 67, 56, 34, 78, 92, 88
对线性表，在下列哪种情况下应当采用链表表示？( )

 ( A )
经常需要随机地存取元素

经常需要进行插入和删除操作
表中元素需要占据一片连续的存储空间
表中元素的个数不变
一个栈的输入序列为1 2 3，则下列序列中不可能是栈的输出序列的是( )。

 ( C )
2 3 1
3 2 1
3 1 2
1 2 3
AOV网是一种（）。

 ( C )
有向图
无向图
无向无环图
有向无环图
采用开放定址法处理散列表的冲突时，其平均查找长度（）。
 ( B )
低于链接法处理冲突
高于链接法处理冲突

与链接法处理冲突相同
高于二分查找
若某二叉树结点的中序遍历的序列为A、B、C、D、E、F、G，后序遍历的序列为B、D、
C、A、F、G、E，则该二叉树结点的前序遍历的序列为（）。

 ( C )
E、G、F、A、C、D、B
E、A、G、C、F、B、D

E、A、C、B、D、G、F
E、G、A、C、D、F、B
以下数据结构中哪一个是非线性结构？（）

 ( D )
队列
栈

线性表
二叉树
设有一个二维数组A[m][n]，假设A[0][0]存放位置在644，A[2][2]存放位置在676，每
个元素占一个空间，则A[3][3]存放位置在（）。

 ( C )
688
678
692
696
树最适合用来表示（）。

 ( C )
有序数据元素
无序数据元素
元素之间具有分支层次关系的数据
元素之间无联系的数据
若有18个元素的有序表存放在一维数组A[19]中，第一个元素放A[1]中，现进行二分查找，
则查找A[3]的比较序列的下标依次为（）。

 ( D )
1，2，3
9，5，2，3
9，5，3
9，4，2，3
对于线性表（7，34，55，25，64，46，20，10）进行散列存储时，若选用H(K)=K %
9作为散列函数，则散列地址为1的元素有（）个。

 ( D )
1
2
3
4

设有6个结点的无向图，该图至少应有（）条边才能确保是一个连通图。

 ( A )
5
6
7
8
对一个算法的评价，不包括如下（）方面的内容。

 ( B )
健壮性和可读性
并行性

正确性
时空复杂度
队列的特点是（）。

 ( B )
先进后出
先进先出
任意位置进出
前面都不正确
下面关于广义表的叙述中，不正确的是（）。
 ( B )
广义表可以是一个多层次的结构
广义表至少有一个元素

广义表可以被其他广义表所共享
广义表可以是一个递归表
若某二叉树结点的中序遍历的序列为A、B、C、D、E、F、G，后序遍历的序列为B、D、
C、A、F、G、E。
21、则该二叉树结点的前序遍历的序列为（）。

 ( C )
E、G、F、A、C、D、B
E、A、G、C、F、B、D

E、A、C、B、D、G、F
E、G、A、C、D、F、B
中缀表达式2+X*(Y+3)的后缀形式是（）。

 ( D )
3 Y X 2 + * +
Y 3 + X * 2 +

2 X Y 3 * + +
2 X Y 3 + * +

在数据结构中，数据元素可由（）。

 ( C )
实体
域
数据项
字段
假定有K个关键字互为同义词，若用线性探测法把这K个关键字存入散列表中，至少要进
行（）次探测。

 ( D )
K-1次
K次
K＋l次
K(K+1)/2次
如表r有个元素，前99999个元素递增有序，则采用（）方法比较次数较少。

 ( A )
直接插入排序
快速排序
归并排序
选择排序

二、多项选择题。本大题共4个小题，每小题 5.0 分，共20.0分。在每小题给出的选项
中，有一项或多项是符合题目要求的。

下述哪些是顺序存储方式的优点？（）

 ( ACDE )
存储密度大

插入和删除运算方便
获取符合某种条件的元素方便
查找运算速度快
可以很方便地存取第i个元素
对一个算法的评价，主要包括如下（）方面的内容。

 ( ACD )
健壮性和可读性
并行性
正确性
时空复杂度
界面友好性
栈和队列的共同特点是（）。

 ( AE )
只允许在端点处插入和删除元素

都是先进后出
都是先进先出
没有共同点
都可以采用顺序存储方式和链式存储方式
以下哪些是队列的基本运算？（）

 ( ABCD )
在队列第i个元素之后插入一个元素
从队头删除一个元素

判断一个队列是否为空
读取队头元素的值

将队列中的元素排序

三、判断题。本大题共10个小题，每小题 3.0 分，共30.0分。
线性表若采用链式存储表示时，其存储结点的地址可连续也可不连续。
 (正确)
线性表若采用链式存储表示, 在删除时不需要移动元素。
 (正确)
在线性链表中删除某个结点时，只需将被删结点释放。
 (错误)
链式栈与顺序栈相比, 一个明显的优点是通常不会出现栈满的情况。
 (正确)
在用循环单链表表示的链式队列中，可以不设队头指针，仅在链尾设置队尾指针
 (正确)
一个广义表的表头总是一个广义表
 (错误)
若一棵二叉树的任一非叶子结点的度为2，则该二叉树为满二叉树。
 (错误)
在一棵二叉树中，假定每个结点只有左子女，没有右子女，对它分别进行前序遍历和后序遍
历，则具有相同的结果。
 (正确)
进行折半搜索的表必须是顺序存储的有序表。
 (正确)
用邻接矩阵存储一个图时，在不考虑压缩存储的情况下，所占用的存储空间大小只与图中的
顶点个数有关，而与图的边数无关。
 (错误)