数据结构上机考试试题
数据结构第五章 查找 答案

数据结构与算法上机作业第五章查找一、选择题1、若构造一棵具有n个结点的二叉排序树,在最坏情况下,其高度不超过 B 。
A. n/2B. nC. (n+1)/2D. n+12、分别以下列序列构造二叉排序数(二叉查找树),与用其他3个序列所构造的结果不同的是 C :A. (100, 80, 90, 60, 120, 110, 130)B. (100, 120, 110, 130, 80, 60, 90)C. (100, 60, 80, 90, 120, 110, 130)D. (100, 80, 60, 90, 120, 130, 110)3、不可能生成下图所示的二叉排序树的关键字的序列是 A 。
A. 4 5 3 1 2B. 4 2 5 3 1C. 4 5 2 1 3D. 4 2 3 1 54、在二叉平衡树中插入一个结点造成了不平衡,设最低的不平衡点为A,并已知A的左孩子的平衡因子为0,右孩子的平衡因子为1,则应作 C 型调整使其平衡。
A. LLB. LRC. RLD. RR5、一棵高度为k的二叉平衡树,其每个非叶结点的平衡因子均为0,则该树共有 C 个结点。
A. 2k-1-1B. 2k-1+1C. 2k-1D. 2k+16、具有5层结点的平衡二叉树至少有 A 个结点。
A. 12B. 11C. 10D. 97、下面关于B-和B+树的叙述中,不正确的是 C 。
A. B-树和B+树都是平衡的多叉树B. B-树和B+树都可用于文件的索引结构C. B-树和B+树都能有效地支持顺序检索D. B-树和B+树都能有效地支持随机检索8、下列关于m阶B-树的说法错误的是 D 。
A. 根结点至多有m棵子树B. 所有叶子结点都在同一层次C. 非叶结点至少有m/2(m为偶数)或m/2+1(m为奇数)棵子树D. 根结点中的数据是有序的9、下面关于哈希查找的说法正确的是 C 。
A. 哈希函数构造得越复杂越好,因为这样随机性好,冲突小B. 除留余数法是所有哈希函数中最好的C. 不存在特别好与坏的哈希函数,要视情况而定D. 若需在哈希表中删去一个元素,不管用何种方法解决冲突都只要简单地将该元素删去即可10、与其他查找方法相比,散列查找法的特点是 C 。
数据结构考试题及答案

数据结构考试题及答案一、选择题(每题2分,共20分)1. 以下哪个不是线性数据结构?A. 数组B. 链表C. 树D. 图2. 在一个单链表中,删除一个节点的操作需要知道该节点的:A. 地址B. 值C. 索引D. 前驱节点的引用3. 栈(Stack)是一种:A. 线性表B. 树状结构C. 图结构D. 散列表4. 哈希表解决冲突最常用的方法是:A. 排序B. 链地址法C. 再散列D. 除留余数法5. 以下哪个排序算法是稳定的?A. 快速排序B. 冒泡排序C. 选择排序D. 堆排序二、简答题(每题10分,共30分)1. 简述数组和链表的区别。
2. 解释二叉搜索树的基本概念及其优势。
3. 什么是递归?请给出一个简单的递归算法例子。
三、计算题(每题25分,共50分)1. 给定一个无序数组,请写出一个时间复杂度为O(n log n)的排序算法,并说明其工作原理。
2. 描述如何使用队列来实现一个简单的文本编辑器的撤销和重做功能。
四、编程题(共30分)编写一个函数,该函数接受一个整数数组作为参数,返回数组中所有元素的和。
如果数组为空,返回0。
答案一、选择题1. 答案:C(树和图都是非线性结构)2. 答案:D(需要前驱节点的引用来删除节点)3. 答案:A(栈是一种后进先出的特殊线性表)4. 答案:B(链地址法是解决哈希冲突的常用方法)5. 答案:B(冒泡排序是稳定的排序算法)二、简答题1. 数组和链表的区别:- 数组是连续的内存空间,链表是非连续的。
- 数组的索引访问速度快,链表需要遍历。
- 数组的大小固定,链表动态可变。
2. 二叉搜索树的基本概念及其优势:- 二叉搜索树是一种特殊的二叉树,左子树上所有节点的值小于它的根节点的值,右子树上所有节点的值大于它的根节点的值。
- 优势:支持快速的查找、插入和删除操作。
3. 递归是函数自己调用自己的过程。
例如,计算n的阶乘的递归算法: ```cint factorial(int n) {if (n <= 1) return 1;return n * factorial(n - 1);}```三、计算题1. 快速排序算法:- 选择一个元素作为“基准”(pivot)。
数据结构上机题

数据结构上机题正文:一、题目描述根据给定的需求,设计并实现一个数据结构,用于解决特定的问题。
二、问题分析1、输入:a) 数据规模:给定的数据规模(例如.10^5)b) 输入格式:输入的数据格式(例如:一行一个整数)c) 输入限制:输入数据的限制条件(例如:输入整数范围在0到100之间)2、需求:a) 需求描述:具体要求及其功能(例如:实现一个栈数据结构,并完成push、pop、top等操作)b) 需求分析:对需求进行分析、理解,确定实现思路3、思路:a) 思路描述:实现的思路(例如:使用数组实现一个栈,利用栈的特点进行push、pop等操作)b) 算法分析:分析算法的时间复杂度、空间复杂度(例如:push操作的时间复杂度是O(1))三、数据结构设计1、数据结构描述:对设计的数据结构进行详细的描述、定义(例如:栈是一种先进后出的数据结构,提供push、pop等操作)2、数据结构实现:具体实现细节(例如:使用数组实现栈,使用指针实现链表等)四、主要函数设计1、函数1:函数描述、输入参数、返回值(例如:push函数用于将元素压入栈中,输入参数是要入栈的元素,返回值是操作是否成功)2、函数2:函数描述、输入参数、返回值(例如:pop函数用于将栈顶元素弹出,输入参数为空,返回值是弹出的元素)五、实验步骤1、步骤1:描述具体实验步骤、流程(例如:首先创建一个空栈)2、步骤2:描述具体实验步骤、流程(例如:依次进行push、pop等操作)3、:::六、实验结果与分析1、结果描述:实验结果(例如:对于给定的数据规模,push、pop等操作的效率)2、结果分析:对实验结果进行分析和讨论(例如:通过比较不同数据规模下的性能表现,得出结论:在较大数据规模下,该数据结构的性能较优)七、总结与展望1、总结:总结本次实验的目的、内容、方法和结果(例如:本次实验主要实现了一个栈数据结构,并验证了其性能优势)2、展望:对进一步的研究和改进提供展望(例如:可以进一步探索不同数据结构的实现方式,比较其性能差异)附件:1、附件1:示例代码实现2、附件2:示例数据集法律名词及注释:1、法律名词1:注释说明(例如:该法律名词的定义和含义)2、法律名词2:注释说明(例如:该法律名词的定义和含义)。
数据结构上机考试题目

选择题在数据结构中,栈(Stack)是一种什么类型的数据结构?A. 线性B. 树形C. 图形D. 非线性但非树形答案:A在二叉树中,每个节点最多有几个子节点?A. 1B. 2C. 3D. 取决于树的层次答案:B以下哪项是哈希表(Hash Table)的主要优点?A. 存储密度大B. 插入和删除元素快C. 支持随机存取D. 存储空间利用率高答案:B哪种数据结构适用于需要频繁插入和删除操作的场景?A. 数组B. 链表C. 栈D. 队列答案:B在图的表示中,什么用于表示节点之间的关系?A. 节点B. 边C. 顶点D. 权重答案:B以下哪种排序算法的时间复杂度是O(n log n)?A. 冒泡排序B. 选择排序C. 插入排序D. 快速排序答案:D填空题在数据结构中,________是一种特殊的线性数据结构,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。
答案:队列(Queue)在树形结构中,除了根节点外,每个节点都有________个父节点。
答案:一________是一种基于比较的排序算法,通过不断将待排序的序列分割成独立的子序列,并对子序列进行排序,最后将有序子序列合并得到完全有序的序列。
答案:归并排序(Merge Sort)在图的遍历中,________遍历是一种深度优先的遍历算法,它沿着树的深度遍历树的节点,尽可能深地搜索树的分支。
答案:深度优先(Depth-First Search)哈希表是通过________函数将关键字映射到表中的位置来存储数据的。
答案:哈希(Hash)在链表中,________用于指向链表中的下一个节点。
答案:指针(Pointer)简答题简述数据结构的定义及其重要性。
答案:数据结构是计算机存储、组织数据的方式。
它指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构的重要性体现在它是计算机程序设计中不可或缺的一部分,它直接影响到程序的运行效率、数据存储的合理性以及数据操作的便捷性。
数据结构上机考试题目及要求

数据结构上机实验考试标准一、评分标准:1.根据考试完成情况,参考平时上机情况评定优、良、中、及格、不及格5个档。
2.成绩分布比例近似为:优15%、良30%、中30%、及格20%、不及格<10%二、评分原则:1.充分参考平时实验完成情况,结合如下原则给出成绩;2.只完成第一题,成绩为良以下成绩(中、及格),若平时上机情况很好,可以考虑良好;3.两道题都完成,成绩为良及以上(优、良),根据完成质量和完成时间给成绩;4.如未完成任何程序,则不及格(根据平时成绩将不及格率控制在10%以下);三、监考要求:1.考试前,要求学生检查电脑是否工作正常,如果不正常及时解决,待所有考生均可正常考试后再发布试题。
2.平时上机完成的程序可以在考试过程直接调用,在考试开始前复制到硬盘当中,考试过程中可以看教材。
3.考试开始后向学生分发考题的电子文档,同时宣读试题,学生可以通过网络或磁盘拷贝试题。
4.考试开始十五分钟之后把网络断开,学生不得再使用任何形式的磁盘。
5.程序检查时,记录其完成时间和完成情况。
除检查执行情况外,还要求学生对代码进行简要讲解,核实其对代码的理解情况和设计思想,两项均合格方视为试题完成。
6.完成考试的学生须关闭电脑立刻离开考场,考试成绩由教务办统一公布,负责教师不在考试现场公布成绩。
数据结构上机实验考试题目(2011年12月23日)题目1.设C={a1,b1,a2,b2,…,a n,b n}为一线性表,采用带头结点的单链表hc(hc为C链表的头指针)存放,设计一个算法,将其拆分为两个线性表(它们都用带头结点的单链表存放),使得:A={a1,a2,…,a n},B={b n,b n-1,…,b1}。
[例] C链表为:C={1,2,3,4,5,6,7,8,9,10}拆分后的A、B链表如下:A={1,3,5,7,9},B={10,8,6,4,2}。
要求:算法的空间复杂度为O(1)。
即利用C链表原来的空间。
数据结构上机考题

05信管《数据结构》上机考题(A卷)
学号:姓名:成绩:
试题:建立一个数据为整型的单链表L,然后将该链表中数据域值最小的那个结点移到链表的最前端。
要求与评分标准:
第一步:建立单链表(30分)
第二步:显示该单链表(10分)
第三步:查找链表中数据域值最小的结点,并将它移到链表的最前端(50分)第四步:显示该单链表,检查上述操作是否成功(10分)
05信管《数据结构》上机考题(B卷)
学号:姓名:成绩:
试题:在一个递增有序的顺序表中插入一个元素,使插入之后仍有序。
要求与评分标准:
第一步:建立一个递增有序的顺序表,注:可以在输入数据时按递增的顺序输入(30分)
第二步:显示该顺序表(10分)
第三步:在顺序表中找到合适的位置插入指定的元素,使插入之后仍有序(50分)第四步:显示该顺序表,检查上述操作是否成功(10分)
05信管《数据结构》上机考题(C卷)
学号:姓名:成绩:
试题:已知单链表L中的元素递增有序,请用高效的办法删除L中元素值大于mink且小于maxk的所有结点(注:mink和maxk由形参给出,它们与链表的数据域同类型且mink且小于maxk)
要求与评分标准:
第一步:建立递增有序的单链表L(30分)
第二步:显示该单链表(10分)
第三步:用高效的办法删除L中元素值大于mink且小于maxk的所有结点(50分)
第四步:显示该单链表,检查上述操作是否成功(10分)。
数据结构机考题库汇总

数据结构机考题库汇总1、在下列对顺序表进行的操作中,算法时间复杂度为O(1)的是(A)。
选项A)访问第i个元素的前驱(1i=n)选项B)在第i个元素之后插入一个新元素(1=i=n)选项C)删除第i个元素(1=i=n)选项D)对顺序表中元素进行排序顺序表是随机存取结构,选项A中实质是查找第i个结点和第i一1个结点,因此时间复杂度为O(1);选项B和C插入和删除都需要移动元素,时间复杂度为O(n);选项D是排序问题,时间复杂度是O(n)~O(n2)。
2、不带头结点的单链表head为空的判定条件是(A)。
选项A)head==NULL选项B)head-next==NULL选项C)head-next==head选项D)head!=NULL在不带头结点的单链表head中,head指向第一个元素结点,head=NULL表示该链表为空。
3、在一个长度为n的顺序表中,在第i个元素之前插入一个新元素时,需向后移动(B)个元素。
选项A)n-i选项B)n-i+1选项C)n-i-1选项D)ii之前共有(i-1)个元素,所以,需移动(n-(i-1))个元素。
4、某程序的时间复杂度为(3n+nlog2n+n2+8),其数量级表示为(C)。
选项A)O(n)选项B)O(nlog2n)选项C)O(n2)选项D)O(log2n)5、在以下的叙述中,正确的是(C)。
选项A)线性表的顺序存储结构优于链表存储结构选项B)线性表的顺序存储结构适用于频繁插入删除数据元素的情况选项C)线性表的链表存储结构适用于频繁插入删除数据元素的情况选项D)线性表的链表存储结构优于顺序存储结构6、对一个具有n个元素的线性表,建立其单链表的时间复杂性为(A)。
选项A)O(n)选项B)O(1)选项C)O(n2)选项D)O(log2n)7、线性表链式存储结构的特点,哪个是错误的(C)。
选项A)逻辑上相邻的元素,其物理位置不一定相邻,元素之间的邻接关系由指针域指示选项B)链表是非随机存取存储结构,对链表的存取必须从头指针开始选项C)链表是一种动态存储结构,链表的结点可用free()申请和用malloc()释放。
数据结构教程上机实验题

编写一个程序ALGO2-1.CPP,实现顺序表的各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化顺序表L(2)依次采用尾插法插入a,b,c,d,e元素(3)输出顺序表L:(4)输出顺序表L长度(5)判断顺序表L是否为空(6)输出顺序表L的第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入f元素(9)输出顺序表L:(10)删除L的第3个元素(11)输出顺序表L:(12)释放顺序表L#include <stdio.h>#include <malloc.h>#define MaxSize 100typedefcharElemType;typedefstruct{ElemType data[MaxSize];int length;}SqList;void Init(SqList *&L){L = (SqList *)malloc(sizeof(SqList));L->length=0;}void CreateList(SqList *&L, ElemType source[],int n) {int i;for(i=0;i<n;i++){L->data[i]=source[i];}L->length=n;}void DisplayList(SqList* L){int i;for(i=0;i<L->length;i++){printf("%c\t",L->data[i]);}printf("\n");}void main(){SqList* h;char a[]={'a','b','c','d','e'};Init(h);printf("before Create length=%d\n",h->length);CreateList(h,a,5);DisplayList(h);printf("after Create length=%d\n",h->length);}。
数据结构上机例题及答案

习题二⒉1描述以下四个概念的区别:头指针变量,头指针,头结点,首结点(第一个结点)。
解:头指针变量和头指针是指向链表中第一个结点(头结点或首结点)的指针;在首结点之前附设一个结点称为头结点;首结点是指链表中存储线性表中第一个数据元素的结点。
若单链表中附设头结点,则不管线性表是否为空,头指针均不为空,否则表示空表的链表的头指针为空。
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);}2.5设线性表中的数据元素是按值非递减有序排列的,试以不同的存储结构,编写一算法,将x插入到线性表的适当位置上,以保持线性表的有序性。
数据结构上机考核试题及答案

1、顺序表的插入与删除#define ListSize 10#define n 8#define Error printftypedef int DataType;typedef struct{DataType data[ListSize];int length;}seqlist;void deletelist(seqlist *L);void insertlist(seqlist *L);main(){seqlist *L=0;int i;char c;printf("请按递减顺序输入%d个整数:\n",n);for(i=0;i<n;i++)scanf("%d",&L->data[i]);L->length=n;printf("\n请选择:\n");printf("A----------------------插入------------------\n");printf("B----------------------删除------------------\n");printf("C----------------------退出------------------\n");scanf("\n%c",&c);while(c!='c'&&c!='C'){if(c=='A'||c=='a')insertlist(L);else deletelist(L);printf("当前顺序表中的数据是:\n");for(i=0;i<L->length;i++)printf("%3d",L->data[i]);printf("\n请再选择:\n");printf("A----------------------插入------------------\n");printf("B----------------------删除------------------\n");printf("C----------------------退出------------------\n");scanf("\n%c",&c);}}void insertlist(seqlist *L){int x,i,j;printf("\n请输入要插入的整数:");scanf("\n%d",&x);printf("\n在下面序列中插入%d\n",x);for(i=0;i<L->length;i++)printf("%3d",L->data[i]);i=0;while(i<L->length&&x<L->data[i])i++;if(i<0||i>L->length+1)Error("\n插入位置错误!\n");else if(L->length>=ListSize)Error("\n表溢出,无法插入!"); else if(x==L->data[i])printf("\n重复插入,不允许!\n");/*=========空白处1===========*/L->data[j+1]=l->data[j];L->data[i]=x;L->length++;/*======================*/}}void deletelist(seqlist *L){int x,i,j,num;printf("\n请输入要删除的整数:");scanf("\n%d",&x);printf("\n在下面序列中删除%d\n",x);for(i=0;i<L->length;i++)printf("%3d",L->data[i]);i=0;num=0;while(i<L->length&&x<L->data[i])i++;if(x!=L->data[i])Error("\n没找到要删除的整数!\n");else{num++;while(L->data[i+1]==x&&i<L->length-1){i++;num++;}printf("\n删除原表中从第%d个位置以后的%d个数据%d\n",i-num+1,num,x); for(j=i+1;j<=L->length-1;j++)/*=====请在下面填入相应的语句======*/L->data[j-num]=L->data[j];L->length=L->length-num;/*=====================*/}}2\ 单链表的插入与删除*/#include <stdio.h>#include <stdlib.h>#include <string.h>#define Error printf#define n 5typedef struct node{int data;struct node *next;}ListNode;typedef ListNode * LinkList;LinkList Createlinklist(void);void Insertlinklist(LinkList head);void Deletelinklist(LinkList head);void Outputlinklist(LinkList head);main(){LinkList head;char c;head=Createlinklist();printf("请选择:\n");printf("A--------------插入-----------------\n");printf("B--------------删除-----------------\n");while(c!='c'&&c!='C'){if(c=='A'||c=='a')Insertlinklist(head);else Deletelinklist(head);Outputlinklist(head);printf("\n请再选择:\n");printf("A--------------插入-----------------\n"); printf("B--------------删除-----------------\n"); printf("C--------------退出-----------------\n"); scanf("\n%c",&c);}}/*****************************/LinkList Createlinklist(){int x;LinkList head,s,r;head=(ListNode*)malloc(sizeof(ListNode));r=head;r->next=NULL;printf("请按递减顺序输入整数(输0 结束):\n"); scanf("%d",&x);while (x!=0){s=(ListNode*)malloc(sizeof(ListNode));s->data=x;s->next=r->next;r->next=s;r=s;scanf("\n%d",&x);}return head;}void Insertlinklist(LinkList head){int x;ListNode *p,*s;int i,j;printf("请输入要插入的整数:");scanf("%d",&x);p=head;j=0;while(p->next&&x<p->next->data){j++;p=p->next;}if(x==p->next->data)Error("重复插入,不允许!\n");else{s=(ListNode *)malloc(sizeof(ListNode));/*=====请在下面填入相应的语句===*/S->data=x;P->next=S;/*====================*/ }}void Deletelinklist(LinkList head){int x;ListNode *p,*r;int i,j;printf("请输入要删除的整数:");scanf("%d",&x);p=head;r=head->next;while(r&&x<r->data){ p=r;r=r->next;}if(r==NULL||x!=r->data)Error("没找到要删除的整数.\n");else{/*==========空白处2=========*/p->next=r->next;free(r);/*====================*/}}void Outputlinklist(LinkList head){ListNode *p;p=head->next;printf("当前链表中数据为:\n");while(p){printf("%6d",p->data);p=p->next;}}/*====数据结构上机考核试题3======*//* 栈的操作#define StackSize 10 #define Error printftypedef int DataType;typedef struct{DataType data[StackSize];int top;}SeqStack;void InitStack(SeqStack *s){s->top=0; }int StackEmpty(SeqStack *S){if (S->top==0)return 1;else return 0;}int StackFull(SeqStack *S){return S->top==StackSize;}void Push(SeqStack *S,DataType x){if(StackFull(S))Error("栈溢出!");/*==========空白处1============*/Else S->data[++(S->top)]=x;/*=====================*/}DataType Pop(SeqStack *S){If(StackEmpty(S))Error(“Stack underflow”);Else return S->data[--(S->top)];/*=========*/}void conversion(int N,int B);main(){int N,B;char ch;printf("进行数值转换请输入Y,退出请输入N:"); scanf("\n%c",&ch);while (ch=='Y'||ch=='y'){printf("请输入需要转换的十进制数:");scanf("%d",&N);printf("\n请输入想要转换的进制数(2,8or16):"); scanf("%d",&B);conversion(N,B);printf("继续转换请输入Y,退出请输入N:");scanf("\n%c",&ch); }}void conversion(int N,int B){ DataType i;SeqStack *S;InitStack(S);while(N){Push(S,N%B); N=N/B; }printf("转换的结果为:");while(!StackEmpty(S)){i=Pop(S);switch(i){case 10:printf("%c",'a');break;case 11:printf("%c",'b');break;case 12:printf("%c",'c');break;case 13:printf("%c",'d');break;case 14:printf("%c",'e');break;case 15:printf("%c",'f');break;default:printf("%d",i); }}printf("\n"); }/*==========数据结构上机考核试题4======*/ /* 队列的操作*/#include <stdio.h>#define QueueSize 100#define Error printftypedef char DataType;typedef struct{int front;int rear;int count;DataType data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q){ Q->front=Q->rear=0;int QueueEmpty(CirQueue *Q){ return Q->count==0; }int QueueFull(CirQueue *Q){ return Q->count==QueueSize; }void EnQueue(CirQueue *Q,DataType x){ if(QueueFull(Q))Error("队列溢出!");e lse{ /*==========空白处1===========*/ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;/*=================*/ }} DataType DeQueue(CirQueue *Q) {DataType temp;if(QueueEmpty(Q))Error("队列下溢!");else{temp=Q->data[Q->front];/*============空白处2===========*/ Q->count--;Q->front=(q->front+1)%QueueSize;/*==============*/return temp;}}void Inputch(CirQueue *Q);void Outputch(CirQueue *Q);main(){ CirQueue *Q=0;char ch;printf("\n 继续进行请按Y,退出请按N:"); scanf("\n%c",&ch);while(ch=='Y'||ch=='y'){ InitQueue(Q);Inputch(Q);Outputch(Q);printf("\n 继续进行请按Y,退出请按N:"); scanf("\n%c",&ch); }}void Inputch(CirQueue *Q){ char ch;printf("\n 请输入字符串并以$为结束符:"); scanf("%c",&ch);while(ch!='$'){ EnQueue(Q,ch);scanf("%c",&ch); }}void Outputch(CirQueue *Q){ char ch;printf("你输入的字符串是:");while(!QueueEmpty(Q)){ch=DeQueue(Q);printf("%c",ch); }printf("\n"); }/*========数据结构上机考核试题5=====*/ /* 二叉树的遍历*/DataType data;struct node *lchild,*rchild;}BinTNode;typedef BinTNode *BinTree;int count;void CreateBinTree(BinTree *T);void Levelorder(BinTree T);main(){BinTree T;char ch1,ch2;printf("\n请选择:\n");ch1='y';while(ch1=='y'||ch1=='Y'){printf("\nA------------------二叉树建立-------------");printf("\nB------------------层次遍历---------------");printf("\nC------------------退出-------------------\n");scanf("\n%c",&ch2);switch(ch2){case 'a':case 'A':printf("请按先序输入建立二叉树存储的结点序列:\n"); CreateBinTree(&T);break;case 'b':case 'B':printf("该二叉树的层次遍历序列为:\n");Levelorder(T);break;case 'c':case 'C':ch1='n';break;default:ch1='n'; }}}void CreateBinTree(BinTree *T){char ch;scanf("\n%c",&ch);if(ch=='0') *T=NULL;else {*T=(BinTNode*)malloc(sizeof(BinTNode));(*T)->data=ch;CreateBinTree(&(*T)->lchild);CreateBinTree(&(*T)->rchild); }}void Levelorder(BinTree T){int i,j;BinTNode *q[20],*p;p=T;if(p!=NULL){i=1;q[i]=p;j=2;}while(i!=j){p=q[i];printf("%3c",p->data);/*==========空白处1==============*/if(p->lchild!=NULL){q[j]=p->lchild; j++;}if(p->rchild!=NULL){q[j]=p->rchild; j++;}i++;/*===========*/}}/*======数据结构上机考核试题6========*//* 求二叉树叶子结点个数*/DataType data;struct node *lchild,*rchild;}BinTNode;typedef BinTNode *BinTree;int count;void CreateBinTree(BinTree *T);void Leafnum(BinTree T);main(){BinTree T;char ch1,ch2;printf("\n请选择:\n");ch1='y';while(ch1=='y'||ch1=='Y'){printf("\nA------------------二叉树建立-------------");printf("\nB------------------求叶子结点个数---------");printf("\nC------------------退出-------------------\n");scanf("\n%c",&ch2);switch(ch2){case 'a':case 'A':printf("请按先序输入二叉树存储的结点序列:\n"); CreateBinTree(&T);break;case 'b':case 'B':count=0;Leafnum(T);printf("该二叉树有%d个叶子.\n",count);break;case 'c':case 'C':ch1='n';break;default:ch1='n';}}}void CreateBinTree(BinTree *T){ char ch;scanf("\n%c",&ch);if(ch=='0') *T=NULL;else {*T=(BinTNode*)malloc(sizeof(BinTNode));(*T)->data=ch;CreateBinTree(&(*T)->lchild);CreateBinTree(&(*T)->rchild); }}void Leafnum(BinTree T){ if(T){if(T->lchild==NULL&&T->rchild==NULL)/*=============空白处1==============*/ count++;Leafnum(T->lchild);Leafnum(T->rchild);/*==================*/}}/*========数据结构上机考核试题7======*//* 二分查找*/#include <stdio.h>#define n 10main(){int R[n],i,k,low,mid,high,m;char ch;printf("请按递增顺序输入10个整数:\n",n);for(i=0;i<n;i++)scanf("%d",&R[i]);printf("需要查找请输入Y,否则输入N:");scanf("\n%c",&ch);while(ch=='y'||ch=='Y'){printf("请输入要查找的整数:\n");scanf("\n%d",&k);low=0;high=n-1;m=0;while(low<=high){ /*========空白处1===========*//*=======请在下面填入相应的语句========*/mid=(low+high)/2;m++;if(R[mid]>k) high=mid-1;else if(R[mid]<k) low=mid+1;else break;/*=============*/ }if(low>high){printf("\n没找到!\n");printf("共进行了%d次比较.\n",m);if(R[mid]<k)mid++;printf("可将此数插入到第%d的位置上.\n",mid+1);}else {printf("\n要找的数据%d在第%d的位置上.\n",k,mid+1); printf("共进行了%d此比较.\n",m); }printf("\n继续查找请输入Y,否则输入N:\n");scanf("\n%c",&ch); }}/*=====数据结构上机考核试题8========*//* 直接插入排序*/#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("******************\n");printf("请选择:(0-2)\n");printf("1-----更新待排数据-------------------\n");printf("2--------直接插入排序----------------\n");printf("0-----退出------------------------\n");scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据(整数):\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:");scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;Insertsort();break;case '0':ch1='n';break;default:ch1='n';}}}void Insertsort(){ int i,j,k;for(i=2;i<=n;i++){ if(R[i].key<R[i-1].key){ /*=========空白处1===========*/R[0]=R[i]; j=j-1;Do{R[j+1]=R[j]; j--; }/*==================*/while(R[0].key<R[j].key);R[j+1]=R[0]; }if(i-1==m){ printf("第%d趟结果是:",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还要输出第几趟结果,不想输出时请输入0):");scanf("\n%d",&m); } }printf("最终排序结果是:");printf("\n");}/*=====数据结构上机考核试题9========*//* 快速排序*/#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;Seqlist R;void Quicksort(int low,int high);int Partition(int i,int j);void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("***********************\n");printf("请选择:(0-2)\n");printf("1---------更新待排序数据-----------------\n"); printf("2---------快速排序-----------------------\n"); printf("0-------------退出---------------------------\n"); scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:"); scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;num=0;Quicksort(1,n);break;case '0':ch1='n';break;default:ch1='n'; }}}int Partition(int i,int j){ RecType pivot=R[i];while(i<j){/*==========空白处1===========*/{while(i<j&&r[j].key>=pivot.key) j--;if(i<j) R[i++]=R[j];while(i<j&&R[i].key<=pivot.key) i++;if(i<j) R[j--]=R[i]; }/*=================*/}R[i]=pivot;return i;}/*****************************/void Quicksort(int low,int high){int pivotpos ,k;if(low<high){pivotpos=Partition(low,high);num++;if(m==num){printf("第%d趟结果是: ",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还要输出第几趟结果,不想输出时请输入0):"); scanf("\n%d",&m);}Quicksort(low,pivotpos-1);Quicksort(pivotpos+1,high);}if(low==1&&high==n){printf("最终排序结果是:");for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");}}/*=======数据结构上机考核试题10========*//* 堆排序*//*下面有2处空白,空白处都标有醒目标记, */#define NULL 0#define n 10#define Error printf#define FLASE 0#define TRUE 1#include <math.h>typedef int KeyType;typedef char InfoType;typedef struct{KeyType key;InfoType otherinfo;}RecType;typedef RecType Seqlist[n+1];int m,num;Seqlist R;void Heapsort();void main(){Seqlist S;int i;char ch1,ch2;printf("请输入10个待排序整数:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);ch1='y';while(ch1=='y'||ch1=='Y'){printf("********************************\n"); printf("请选择:(0-2)\n");printf("1----------更新待排序数据-----------\n"); printf("2---------堆排序-----------------------\n"); printf("0----------退出----------------------\n"); scanf("\n%c",&ch2);switch(ch2){case '1':printf("请输入10个更新数据:\n");for(i=1;i<=n;i++)scanf("%d",&S[i].key);break;case '2':printf("请输入要输出第几趟结果:"); scanf("\n%d",&m);for(i=1;i<=n;i++)R[i].key=S[i].key;Heapsort();break;case '0':ch1='n';break;default:ch1='n';}}}/********************************/void Heapify(int low,int high){int large;RecType temp=R[low];for(large=2*low;large<=high;large*=2){/*==========空白处1=========*//*=====请在下面填入相应的语句=====*/If(large<high&&R[large].key<R[large+1].key) large++;/*=================*/if(temp.key>=R[large].key)break;R[low]=R[large];low=large;}R[low]=temp;}/***********************/void BuildHeap(){int i;/*==========空白处2===========*//*===请在下面填入相应的建堆操作语句==*/for(i=n/2; i>0; i--)Heapify(i,n) ;/*================*/}/****************************/void Heapsort(){int i,k;BuildHeap();for(i=n;i>1;i--){R[0]=R[1];R[1]=R[i];R[i]=R[0];if(i==(n-m+1)){printf("第%d趟结果是:\n",m);for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n");printf("请输入还想输出第几趟结果,不想输出时请输入0):"); scanf("\n%d",&m);}Heapify(1,i-1);}printf("最终排序结果是:\n");for(k=1;k<=n;k++)printf("%5d",R[k].key);printf("\n"); }1. 顺序表的插入与删除/*========空白处1========*/L->data[j+1]=l->data[j];L->data[i]=x;L->length++;/*======空白处2=======*/L->data[j-num]=L->data[j];L->length=L->length-num;2.单链表的插入与删除/*=====空白处1====*/S->data=x;S->next=P->next;P->next=S;/*====空白处2=====*/p->next=r->next;free(r);3. 栈的操作/*=======空白处1========*/Else S->data[++(S->top)]=x;/*=======空白处2========*/If(StackEmpty(S))Error(“Stack underflow”);Else return S->data[--(S->top)];4.队列的操作/*========空白处1========*/Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;/*========空白处2========*/Q->count--;Q->front=(q->front+1)%QueueSize;5. 二叉树的遍历/*========空白处1========*/if(p->lchild!=NULL){q[j]=p->lchild; j++;} if(p->rchild!=NULL){q[j]=p->rchild; j++;} i++;6. 求二叉树叶子结点个数/*=======空白处1=======*/count++;Leafnum(T->lchild);Leafnum(T->rchild);7. 二分查找/*=======空白处1=======*/mid=(low+high)/2;m++;if(R[mid]>k) high=mid-1;else if(R[mid]<k) low=mid+1;else break;8. 直接插入排序/*=========空白处1=========*/R[0]=R[i]; j=j-1;Do{R[j+1]=R[j]; j--; }9. 快速排序/*=========空白处1========*/{while(i<j&&r[j].key>=pivot.key) j--;if(i<j) R[i++]=R[j];while(i<j&&R[i].key<=pivot.key) i++;if(i<j) R[j--]=R[i]; }10. 堆排序=========空白处1=========*/If(large<high&&R[large].key<R[large+1].key) large++; ========空白处2=========*/for(i=n/2; i>0; i--)Heapify(i,n) ;。
数据结构上机考试(含答案)

《数据结构》上机练习题1、设有两个有序序列,利用归并排序将它们排成有序表,并输出。
2、设有一有序序列,从键盘输入一个数,判别是否在序列中,如果在输出“YSE”;否则,将它插入到序列中使它仍然有序,并输出排序后的序列。
3、设有一有序序列,从键盘输入一个数,判别是否在序列中,如果不在,则输出“NO”,否则,将它从序列中删除它,并输出删除后的序列。
4、从键盘输入一组任意数据,建立一个有序链表,并从链头开始输出该链,使输出结果是有序的。
5、从键盘输入一组任意数据,建立一个包含所有输入数据的单向循环链表,并从链表的任意开始,依次输出该链表中的所有结点。
10、设有一个链表,(自己建立,数据从键盘输入),再从键盘输入一个数,判别是否在链表中,如果不在,则输出“NO“,否则,将它从链表中删除,并输出删除后的链表。
11、设有一个链表,(自己建立,数据从键盘输入),再从键盘输入一个数,判别是否在链表中,如果在输出“YSE”,否则,将它从插入到链头,并输出插入后的链表。
12、设有一个链表,(自己建立,数据从键盘输入),再从键盘输入一个数,判别是否在链表中,如果在输出“YSE”,否则,将它从插入到链尾,并输出插入后的链表。
13、编写栈的压栈push、弹栈pop函数,从键盘输入一组数据,逐个元素压入堆栈,然后再逐个从栈中弹出它们并输出。
14、编写栈的压栈push、弹栈pop函数,用它判别()的匹配问题。
15、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树中序遍历的结果。
16、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树先序遍历的结果。
17、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树后序遍历的结果。
18、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树的总结点数。
19、按类似先序遍历结果输入一序列,建立一棵二叉树(算法6、4),输出二叉树叶子结点数。
数据结构考试试题及答案

数据结构考试试题及答案一、选择题(每题2分,共20分)1. 在数据结构中,线性表的顺序存储结构通常使用什么类型的数据结构来实现?A. 栈B. 队列C. 数组D. 链表答案:C2. 下列选项中,哪一个不是二叉树的性质?A. 任意节点的左子树和右子树的深度可能不同B. 任意节点的左子树和右子树的深度相同C. 任意节点的左子树和右子树的节点数可能不同D. 任意节点的左子树和右子树的节点数相同答案:B3. 哈希表的冲突解决方法不包括以下哪种?A. 开放定址法B. 链地址法C. 线性探测法D. 排序法答案:D4. 以下哪种排序算法的时间复杂度最低?A. 冒泡排序B. 快速排序C. 插入排序D. 归并排序答案:B5. 在图的遍历算法中,深度优先搜索(DFS)使用的栈是:A. 系统栈B. 显式栈C. 隐式栈D. 以上都不是答案:B6. 以下哪种数据结构可以有效地实现稀疏矩阵的存储?A. 顺序存储B. 链表C. 散列D. 邻接矩阵答案:C7. 在二叉搜索树中,插入一个新节点后,树的平衡因子可能为:A. -2B. 0C. 2D. 3答案:A8. 堆数据结构中,父节点的值总是大于其子节点的值,这种堆被称为:A. 最小堆B. 最大堆C. 完全二叉树D. 满二叉树答案:B9. 以下哪个算法不是动态查找表的算法?A. 直接查找B. 二分查找C. 斐波那契查找D. 哈希查找答案:A10. 在图的遍历算法中,广度优先搜索(BFS)使用的栈是:A. 系统栈B. 显式栈C. 隐式栈D. 以上都不是答案:C二、填空题(每题2分,共20分)1. 在数据结构中,栈是一种______结构,遵循后进先出(LIFO)的原则。
答案:线性2. 一个具有n个顶点的无向图的边数最多为______。
答案:n*(n-1)/23. 快速排序算法的时间复杂度在最坏情况下为______。
答案:O(n^2)4. 在哈希表中,如果一个关键字的哈希地址已经被占用,则需要进行______。
数据结构上机考试试题(C++语言版)

数据结构上机考试试题(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<iomanip.h>#include<stdlib.h>#include"linearlist1.h"//初始化线性表void InitList(LinearList& L, int ms){L.list=new ElemType[ms];if(!L.list) {cerr<<"Memory allocation failure!"<<endl;exit(1);}L.size=0;L.MaxSize=ms;}//清空线性表void ClearList(LinearList& L){L.size=0;}//求线性表长度int ListSize(LinearList& L){return L.size;}//检查线性表是否为空bool ListEmpty(LinearList& L){return L.size==0;}//检查线性表是否为满bool ListFull(LinearList& L){return L.size==L.MaxSize;}//遍历线性表void TraverList(LinearList& L){for(int i=0; i<L.size; i++) cout<<L.list[i]<<' ';cout<<endl;}//从线性表中查找元素bool FindList(LinearList& L, ElemType& item) {for(int i=0; i<L.size; i++)if(L.list[i]==item) {item=L.list[i];return true;}return false;}//更新线性表中的给定元素bool UpdateList(LinearList& L, const ElemType& item){for(int i=0; i<L.size; i++)if(L.list[i]==item) {L.list[i]=item;return true;}return false;}//向线性表的表头、表尾或合适位置插入元素bool InsertList(LinearList& L, const ElemType& item, int mark) {if(ListFull(L)) return false;if(mark>0) {for(int i=L.size-1; i>=0; i--)L.list[i+1]=L.list[i];L.list[0]=item;}else if(mark<0) L.list[L.size]=item;else {for(int i=0; i<L.size; i++)if(item<L.list[i]) break;for(int j=L.size-1; j>=i; j--)L.list[j+1]=L.list[j];L.list[i]=item;}L.size++;return true;}//从线性表中删除表头、表尾或等于给定值的元素bool DeleteList(LinearList& L, ElemType& item, int mark){if(ListEmpty(L)) return false;if(mark>0) {item=L.list[0];for(int i=1; i<L.size; i++)L.list[i-1]=L.list[i];}else if(mark<0) item=L.list[L.size-1];else { for(int i=0; i<L.size; i++)if(L.list[i]==item) break;if(i>=L.size)return false;else item=L.list[i];for(int j=i+1; j<L.size; j++)L.list[j-1]=L.list[j];}L.size--;return true;}//对线性表按升序或降序输出void OrderOutputList(LinearList& L, int mark){int* b=new int[L.size];int i,k;for(i=0; i<L.size; i++) b[i]=i;for(i=1; i<L.size; i++) {k=i-1;for(int j=i; j<L.size; j++) {if(mark==1 && L.list[b[j]]<L.list[b[k]]) k=j;if(mark!=1 && L.list[b[k]]<L.list[b[j]]) k=j;}if(k!=i-1) {int x=b[i-1]; b[i-1]=b[k]; b[k]=x;} }for(i=0; i<L.size; i++)cout<<L.list[b[i]]<<' ';cout<<endl;}#include<iomanip.h>const int ML=10;#include"linearlist1.h"//主文件listmain1.cppvoid main(){LinearList a;InitList(a,ML);int i;ElemType x;//依次向线性表a表尾插入5个整数元素cout<<"从键盘输入5个整数:";for(i=0; i<5; i++) {cin>>x;InsertList(a,x,-1);}//依次向线性表a表头插入2个整数元素cout<<"从键盘输入2个整数:";cin>>x; InsertList(a,x,1);cin>>x; InsertList(a,x,1);//按不同次序遍历输出线性表aTraverList(a);OrderOutputList(a,1);OrderOutputList(a,0);//把线性表a中的所有元素依次有序插入到一个新线性表b中"LinearList b;InitList(b,ML);for(i=0; i<a.size; i++)InsertList(b, a.list[i], 0);//输出线性表bTraverList(b);//从线性表a中分别删除表头、表尾、给定值元素if(DeleteList(a,x,1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;if(DeleteList(a,x,-1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;cout<<"从键盘上输入一个待删除的整数:";cin>>x;if(DeleteList(a,x,0)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;//输出线性表aTraverList(a);}。
数据结构上机实验(两次共五题).

数据结构上机实验(两次共五题)
1、约瑟夫环:将编号为1,2,…,n的n个人按顺时针方向围坐一圈,每人持
有一个密码(正整数)。
一开始任选一个正整数作为报数上限值m,从第一个开始按顺时针方向自1开始报数,报到m时停止报数。
报m的人出列,将他的密码作为新的m值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
设m 的初值为20,密码为:3,1,7,2,4,8,4。
2、编一程序:①建立一个数据域为1至10的带头结点的链表;
②将此链表就地逆转。
3、编写构造Huffman树和Huffman编码的程序。
已知:字符a,b,c,d,e,f,g的权值分别为{4,10,8,5,3,1,2}
4、编一程序算出教材中图7.30(p185)的关键路径
5、一程序实现堆排序。
已知输入关键字序列为:49,38,65,97,76,13,27,48
要求输出每趟排序的结果。
中大实践考核数据结构试题和答案(上机考试)

数据结构样题1、已知整数a、b,假设函数succ(x)=x+1、pred(x)=x-1,不许直接用“+”、“-”运算符号,也不许用循环语句,只能利用函数succ( )和pred( ),试编写计算a+b,a-b的递归函数add(a,b),sub(a,b),并在主程序中验证函娄的正确性。
#include "stdio.h"#include "conio.h"int succ(int x){return x+1;}int pred(int x){return x-1;}int add(int a,int b){if(b==0) return a;if(b>0) return succ(add(a,pred(b)));else return pred(add(a,succ(b)));}int sub(int a,int b){if(b==0) return a;if(b>0) return pred(sub(a,pred(b)));else return succ(sub(a,succ(b)));}void main(){int k,a,b;clrscr();printf("\n Please input a b: ");scanf("%d%d",&a,&b);printf("\n a+b=%d",a+b);printf("\n a-b=%d",a-b);printf("\n add(a,b)=%d",add(a,b));printf("\n sub(a,b)=%d",sub(a,b));if((a+b==add(a,b))&&(a-b==sub(a,b)))printf("\n It's right! ");else printf("\n It's wrong! \n\n");}样题2 试编写一个求解Josephus问题的函数。
数据结构考试试题及答案

数据结构考试试题及答案一、选择题(每题2分,共60分)1. 数据结构是指()。
A. 用来存储和组织数据的方式和方法B. 构建数据的逻辑关系C. 存储和处理数据的工具和技术D. 对数据进行操作和管理的过程2. 下列哪种数据结构是线性结构()。
A. 树B. 图C. 队列D. 堆3. 下列哪种数据结构是非线性结构()。
A. 栈B. 队列C. 数组D. 树4. 栈是一种()。
A. 先进先出的数据结构B. 先进后出的数据结构C. 后进先出的数据结构D. 后进后出的数据结构5. 在二叉树中,每个节点最多有几个孩子节点()。
A. 0B. 1C. 2D. 36. 下列哪种排序算法的时间复杂度最好()。
A. 冒泡排序B. 插入排序C. 快速排序D. 归并排序7. 哈希表的查找时间复杂度是()。
A. O(1)B. O(logn)C. O(n)D. O(nlogn)8. 链表的插入和删除操作时间复杂度是()。
A. O(1)B. O(logn)C. O(n)D. O(nlogn)9. 广度优先搜索算法一般使用()数据结构来实现。
A. 栈B. 队列C. 堆D. 树10. 什么是递归()。
A. 函数调用自身的过程B. 通过循环完成的过程C. 一种数据结构D. 没有调用其他函数的过程二、填空题(每题2分,共20分)1. 数据结构中,线性表是由一系列 _______________ 元素构成的数据结构。
2. 在树结构中,每个节点可以有 _______________ 个子节点。
3. 在图结构中,节点之间的关系可以用 _______________ 来表示。
4. _______________ 是一种递归定义的数据结构,它由若干个节点组成,每个节点都有零个或多个子节点。
5. 在堆排序中,堆是一种 _______________ 数据结构。
6. _______________ 是一种常用的搜索算法,常用于解决最短路径问题。
7. 在散列表中,使用 _______________ 来解决冲突问题。
数据结构考试题库及答案

数据结构考试题库及答案一、选择题1. 下列哪个不是线性结构?A. 栈B. 队列C. 双向链表D. 树答案:D2. 在顺序存储结构中,数据元素的物理位置与逻辑位置相同的是哪种结构?A. 栈B. 队列C. 线性表D. 树答案:C3. 下列哪种排序算法的时间复杂度是O(nlogn)?A. 冒泡排序B. 选择排序C. 快速排序D. 插入排序答案:C4. 在二叉树中,度为0的节点称为()。
A. 根节点B. 内节点C. 叶子节点D. 父节点答案:C5. 下列哪种图的邻接矩阵是对称的?A. 有向图B. 无向图C. 有向连通图D. 无向连通图答案:B二、填空题6. 在链表中的每个节点至少包含两个部分:一个是存储数据元素的数据域,另一个是存储下一个节点地址的指针域。
7. 在顺序表中,元素之间的逻辑关系是由它们的相对位置来体现的。
8. 快速排序的基本思想是:在待排序序列中选取一个基准元素,将序列中所有小于基准元素的元素放在基准元素前面,所有大于基准元素的元素放在基准元素后面。
9. 图中的每个节点称为顶点,顶点之间的连线称为边。
10. 在哈希表中,哈希函数的目的是将关键字映射到散列地址。
三、判断题11. 在顺序表中插入一个元素的时间复杂度为O(1)。
()答案:错误。
插入一个元素的时间复杂度为O(n),因为可能需要移动其他元素。
12. 在链表中删除一个元素的时间复杂度为O(n)。
()答案:错误。
删除一个元素的时间复杂度为O(1),只要找到该元素的前一个节点即可。
13. 二分查找只适用于有序的顺序表。
()答案:正确。
14. 在二叉树中,任意节点的度数不会超过2。
()答案:正确。
15. 图的邻接表表示法比邻接矩阵表示法更加节省空间。
()答案:正确。
四、应用题16. 请用C语言实现一个顺序栈的数据结构,并给出入栈、出栈和判断栈空的操作。
答案:```c#define MAXSIZE 100typedef struct {int data[MAXSIZE];int top;} SeqStack;// 初始化栈void InitStack(SeqStack s) {s->top = -1;}// 判断栈是否为空int StackEmpty(SeqStack s) {return s->top == -1;}// 入栈int Push(SeqStack s, int x) {if (s->top == MAXSIZE - 1) {return 0; // 栈满}s->data[++s->top] = x;return 1;}// 出栈int Pop(SeqStack s, int x) {if (s->top == -1) {return 0; // 栈空}x = s->data[s->top--];return 1;}```17. 请简述二分查找的基本思想。
十套数据结构试题及答案

数据构造试卷〔一〕一、单项选择题〔每题 2 分,共20分〕1.栈和队列的共同特点是( a )。
A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.用链接方式存储的队列,在进展插入运算时( d ).A. 仅修改头指针B. 头、尾指针都要修改C. 仅修改尾指针D.头、尾指针可能都要修改3.以下数据构造中哪一个是非线性构造?( d )A. 队列B. 栈C. 线性表D. 二叉树4.设有一个二维数组A[m][n],假设A[0][0]存放位置在644(10),A[2][2]存放位置在676(10),每个元素占一个空间,问A[3][3](10)存放在什么位置?脚注(10)表示用10进制表示。
cA.688 B.678 C.692 D.6965.树最适合用来表示( c )。
A.有序数据元素B.无序数据元素C.元素之间具有分支层次关系的数据D.元素之间无联系的数据6.二叉树的第k层的结点数最多为( d ).A.2k-1 B.2K+1 C.2K-1 D. 2k-17.假设有18个元素的有序表存放在一维数组A[19]中,第一个元素放A[1]中,现进展二分查找,那么查找A[3]的比拟序列的下标依次为( c d)A. 1,2,3B. 9,5,2,3C. 9,5,3D. 9,4,2,38.对n个记录的文件进展快速排序,所需要的辅助存储空间大致为 cA. O〔1〕B. O〔n〕C. O〔1og2n〕D. O〔n2〕9.对于线性表〔7,34,55,25,64,46,20,10〕进展散列存储时,假设选用H〔K〕=K %9作为散列函数,那么散列地址为1的元素有〔 c d〕个,A.1 B.2 C.3 D.410.设有6个结点的无向图,该图至少应有( a )条边才能确保是一个连通图。
二、填空题〔每空1分,共26分〕1.通常从四个方面评价算法的质量:____时间正确性_____、____占用内存_易读性____、____复杂度__强壮性___和_____准确度_ 高效率___。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构上机考试试题(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!"<<endl;
exit(1);
}
=0;
=ms;
}
//清空线性表
void ClearList(LinearList& L)
{
=0;
}
//求线性表长度
int ListSize(LinearList& L)
{
return ;
}
//检查线性表是否为空
bool ListEmpty(LinearList& L)
{
return ==0;
}
//检查线性表是否为满
bool ListFull(LinearList& L)
{
return ==;
}
//遍历线性表
void TraverList(LinearList& L)
{
for(int i=0; i<; i++) cout<<[i]<<' ';
cout<<endl;
}
//从线性表中查找元素
bool FindList(LinearList& L, ElemType& item) {
for(int i=0; i<; i++)
if[i]==item) {
item=[i];
return true;
}
return false;
}
//更新线性表中的给定元素
bool UpdateList(LinearList& L, const ElemType& item)
{
for(int i=0; i<; i++)
if[i]==item) {
[i]=item;
return true;
}
return false;
}
//向线性表的表头、表尾或合适位置插入元素
bool InsertList(LinearList& L, const ElemType& item, int mark) {
if(ListFull(L)) return false;
if(mark>0) {
for(int i=; i>=0; i--)
[i+1]=[i];
[0]=item;
}
else if(mark<0) []=item;
else {for(int i=0; i<; i++)
if(item<[i]) break;
for(int j=; j>=i; j--)
[j+1]=[j];
[i]=item;
}
++;
return true;
}
//从线性表中删除表头、表尾或等于给定值的元素
bool DeleteList(LinearList& L, ElemType& item, int mark)
{
if(ListEmpty(L)) return false;
if(mark>0) {
item=[0];
for(int i=1; i<; i++)
[i-1]=[i];
}
else if(mark<0) item=[];
else { for(int i=0; i<; i++)
if[i]==item) break;
if(i>=
return false;
else item=[i];
for(int j=i+1; j<; j++)
[j-1]=[j];
}
;
return true;
}
//对线性表按升序或降序输出
void OrderOutputList(LinearList& L, int mark)
{
int* b=new int[];
int i,k;
for(i=0; i<; i++) b[i]=i;
for(i=1; i<; i++) {
k=i-1;
for(int j=i; j<; j++) {
if(mark==1 && [b[j]]<[b[k]]) k=j;
if(mark!=1 && [b[k]]<[b[j]]) k=j;
}
if(k!=i-1) {int x=b[i-1]; b[i-1]=b[k]; b[k]=x;} }
for(i=0; i<; i++)
cout<<[b[i]]<<' ';
cout<<endl;
}
#include<>
const int ML=10;
#include""
//主文件
void main()
{
LinearList a;
InitList(a,ML);
int i;
ElemType x;
//依次向线性表a表尾插入5个整数元素
cout<<"从键盘输入5个整数:";
for(i=0; i<5; i++) {
cin>>x;
InsertList(a,x,-1);
}
//依次向线性表a表头插入2个整数元素
cout<<"从键盘输入2个整数:";
cin>>x; InsertList(a,x,1);
cin>>x; InsertList(a,x,1);
//按不同次序遍历输出线性表a
TraverList(a);
OrderOutputList(a,1);
OrderOutputList(a,0);
//把线性表a中的所有元素依次有序插入到一个新线性表b中" LinearList b;
InitList(b,ML);
for(i=0; i<; i++)
InsertList(b, [i], 0);
//输出线性表b
TraverList(b);
//从线性表a中分别删除表头、表尾、给定值元素
if(DeleteList(a,x,1)) cout<<"Delete success!"<<endl;
else cout<<"Delete fail!"<<endl;
if(DeleteList(a,x,-1)) cout<<"Delete success!"<<endl;
else cout<<"Delete fail!"<<endl;
cout<<"从键盘上输入一个待删除的整数:";
cin>>x;
if(DeleteList(a,x,0)) cout<<"Delete success!"<<endl;
else cout<<"Delete fail!"<<endl;
//输出线性表a
TraverList(a);
}。