数据结构上机答案
数据结构上机例题及答案
习题二⒉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 章绪论课后习题讲解1. 填空⑴()是数据的基本单位,在计算机程序中通常作为一个整体进行考虑与处理。
【解答】数据元素⑵()是数据的最小单位,()是讨论数据结构时涉及的最小数据单位。
【解答】数据项,数据元素【分析】数据结构指的是数据元素以及数据元素之间的关系。
⑶从逻辑关系上讲,数据结构主要分为()、()、()与()。
【解答】集合,线性结构,树结构,图结构⑷数据的存储结构主要有()与()两种基本方法,不论哪种存储结构,都要存储两方面的内容:()与()。
【解答】顺序存储结构,链接存储结构,数据元素,数据元素之间的关系⑸算法具有五个特性,分别是()、()、()、()、()。
【解答】有零个或多个输入,有一个或多个输出,有穷性,确定性,可行性⑹算法的描述方法通常有()、()、()与()四种,其中,()被称为算法语言。
【解答】自然语言,程序设计语言,流程图,伪代码,伪代码⑺在一般情况下,一个算法的时间复杂度是()的函数。
【解答】问题规模⑻设待处理问题的规模为n,若一个算法的时间复杂度为一个常数,则表示成数量级的形式为(),若为n*log25n,则表示成数量级的形式为()。
【解答】Ο(1),Ο(nlog2n)【分析】用大O记号表示算法的时间复杂度,需要将低次幂去掉,将最高次幂的系数去掉。
2. 选择题⑴顺序存储结构中数据元素之间的逻辑关系是由()表示的,链接存储结构中的数据元素之间的逻辑关系是由()表示的。
A 线性结构B 非线性结构C 存储位置D 指针【解答】C,D【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素,其逻辑关系由存储位置(即元素在数组中的下标)表示;链接存储结构中一个数据元素对应链表中的一个结点,元素之间的逻辑关系由结点中的指针表示。
⑵假设有如下遗产继承规则:丈夫与妻子可以相互继承遗产;子女可以继承父亲或母亲的遗产;子女间不能相互继承。
则表示该遗产继承关系的最合适的数据结构应该是()。
数据结构上机答案(c语言版)
数据结构上机答案(c语言版)实习一:1、编写一个读入一个字符串,把它存入一个链表,并按相反的次序打印的程序。
2、设有一个单位的人员工资有如下信息:name、department、base pay、allowance、total。
现从键盘输入一组人员工资数据并将它们存储到名为paydata的文件中;再从paydata取出工资数据并给每个人的base pay增加100元,增加后将工资数据显示于屏幕(每行1人)。
请编写能够完成上述工作的程序。
代码如下:1.#include#include#includevoid main(){char x;struct node //定义个结构node{char c;struct node *next;};struct node *head,*pb,*pf,*p,*s,*t; //定义指针printf("请输入字符串,按Enter结束!\n");for(int i=0;x!='\n';i++){pb=(struct node *)malloc(sizeof(struct node));//动态分配n字节的内存空间scanf("%c",&pb->c); //输入字符x=pb->c;if(i==0){ //输入的首个字符作为头结点pfhead=pb;pf=head;}else if(pb->c!='\n'){ //如果输入的是Enter,输入终止,否则把字符依次存入链表pf->next=pb; //把输入的字符pb存在pf后,pb后为空pb->next=NULL;pf=pb;//pb赋给pf,重复上述操作p=head;}}for(;p!=NULL;p=p->next)s=p; //把指向链表的最后一个字符的指针赋给sprintf("输出结果为:\n");printf("%c",s->c);//输出链表的最后一个字符for(p=head;s!=head;)//若s==head,该链表只有一个字符。
数据结构习题参考答案
数据结构习题参考答案一、栈和队列1. 栈是一种具有后进先出(Last In First Out)特性的线性数据结构。
常用方法:- push(x): 将元素x压入栈顶;- pop(): 弹出栈顶元素;- top(): 返回栈顶元素;- isEmpty(): 判断栈是否为空;例题解答:(1)题目描述:使用栈实现队列的功能。
解答:使用两个栈,一个用于入队操作,一个用于出队操作。
入队操作:直接将元素压入入队栈中;出队操作:如果出队栈为空,则将入队栈的元素逐个弹出并压入出队栈,此时出队栈的栈顶元素即为要弹出的元素。
复杂度分析:入队操作的时间复杂度为O(1),出队操作的平均时间复杂度为O(1)。
(2)题目描述:判断括号序列是否合法,即括号是否完全匹配。
解答:使用栈来处理括号序列,遇到左括号则入栈,遇到右括号则与栈顶元素进行匹配,如果匹配成功则继续处理剩余字符,如果不匹配则判定为非法序列。
算法步骤:- 初始化一个空栈;- 从左到右遍历括号序列,对于每个字符执行以下操作:- 如果是左括号,则将其入栈;- 如果是右括号,则将其与栈顶元素进行匹配:- 如果栈为空,则判定为非法序列;- 如果栈顶元素与当前字符匹配,则将栈顶元素出栈,继续处理剩余字符;- 如果栈顶元素与当前字符不匹配,则判定为非法序列。
- 遍历结束后,如果栈为空,则括号序列合法;否则,括号序列非法。
复杂度分析:时间复杂度为O(n),其中n为括号序列的长度。
2. 队列是一种具有先进先出(First In First Out)特性的线性数据结构。
常用方法:- enqueue(x): 将元素x入队;- dequeue(): 出队并返回队首元素;- getFront(): 返回队首元素;- isEmpty(): 判断队列是否为空;例题解答:(1)题目描述:使用队列实现栈的功能。
解答:使用两个队列,一个用于入栈操作,一个用于出栈操作。
入栈操作:直接将元素入队入栈队列中;出栈操作:如果出栈队列为空,则将入栈队列的元素逐个出队并入队出栈队列,此时出栈队列的队首元素即为要出栈的元素。
《数据结构习题解析与上机指导》参考答案
参考答案第1章一、选择题1. B2. C3. B4. C二、填空题1. 数据、数据2. 基本单位3. 数据项、数据项4. 相互关系、组织形式5. 逻辑关系、逻辑关系、数学模型6. 存储结构、存储结构7. 数据的运算、数据的运算、数据的运算8. 集合、集合9. 线性结构10. 树型结构11. 多对多12. 非线性结构、线性结构、非线性结构13. 顺序存储14. 链接存储15. 稠密索引、稀疏索引、稠密索引、稀疏索引、稠密索引、稀疏索引16. 散列存储17. 有限序列18. 有穷19. 确定、相同20. 可行、有限、具体实现21. 正确性、可读性、健壮性、效率22. 运行时间、所占据空间23. 存储空间三、判断题1. 错误:树型结构也可以用顺序方式迚行存储。
2. 错误:数据元素是数据的基本单位,数据项是数据的最小单位。
3. 错误:算法用各种计算机语言描述表现为一个程序,但是不等于程序,程序逻辑不一定能满足有穷性。
4. 正确。
5. 正确。
6. 正确。
7. 正确。
8. 正确。
四、综合题1. 该算法的时间复杂度为:O(m×n)。
2. 该算法的时间复杂度为:3. 该算法的时间复杂度为:O(m×n×t)。
4. 该算法的时间复杂度为:log3(n)。
5. 该算法的时间复杂度为:。
第2章一、选择题1. A2. C3. A4. D5. D6. A7. B8. D9. B10. C11. C 12. C 13. D 14. D二、填空题1. 一对一2. 直接前驱、直接后继3. 有限序列、长度、空表4. 顺序存储结构、逻辑顺序、地址相邻5. 仸意、仸意、不连续、逻辑关系6. 数据域、指针域、链域7. 非顺序、非顺序映像8. 循环链表9. 双向链表10. 所指向的结点本身11. P->next=p->next->next12. P->next->prior=P->prior13. 线性表14. 双链表15. n-i+116. n-i17. S->next=P->next; P->next=S18. p->prior->next=S;s->prior=p->prior;s->next=p;p->prior=s;19. head(tail(tail((head(tail(head(A))))))20. O(n)21. (L==L->Next) && (L==L->Prior)22. 线性23. 顶三、判断题1. 错误:链表存储中,结点之间可以连续也可以不连续,但结点内部是连续的。
华南农业大学数据结构上机实验答案
华南农业大学实验一实验一实验一实验一实验一实验一实验一实验一实验一实验一实验一实验一实验一#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));=0;=LIST_INIT_SIZE;r eturn OK;}int Load_Sq(SqList &L){i nt i;i f==0)printf("The List is empty!");{printf("The List is:");for(i=0;i<;i++)printf("% d",[i]);}p rintf("\n");r eturn OK;}int ListInsert_Sq(SqList &L,int i,int e){i f(i<1||i>+1)return ERROR;E lemType *newbase,*q,*p;i f>={newbase=(ElemType*)realloc,+LISTINCREMENT)*sizeof(ElemType));=newbase;+=LISTINCREMENT;}q=&[i-1]);f or(p=&[]);p>=q;--p)*(p+1)=*p;*q=e;++;r eturn OK;}int ListDelete_Sq(SqList &L,int i,int &e)E lemType *q,*p;i f(i<1||i>return ERROR;p=&[i-1]);e=*p;q=+;f or(++p;p<=q;p++)*(p-1)=*p;;r eturn OK;}int main(){S qList T;i nt a,i;E lemType e,x;i f(InitList_Sq(T)){printf("A Sequence List Has Created.\n");}w hile(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d%d",&i,&x);if(!ListInsert_Sq(T,i,x))printf("Insert Error!\n");elseprintf("The Element %d is Successfully Inserted!\n",x);break;case 2: scanf("%d",&i);if(!ListDelete_Sq(T,i,e))printf("Delete Error!\n");elseprintf("The Element %d is Successfully Deleted!\n",e);break;case 3: Load_Sq(T);break;case 0: return 1;}}}222222#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); =0;=LIST_INIT_SIZE;r eturn OK;}int Load_Sq(SqList &L){i nt i;f or(i=0;i<;i++)printf("%d ",[i]);p rintf("\n");r eturn OK;}int ListLength(SqList L){r eturn ;}int GetElem(SqList L,int i,ElemType &e){e=[i-1];r eturn OK;}int ListInsert_Sq(SqList &L,int i,int e){i f(i<1||i>+1)return ERROR;E lemType *p,*q,*newbase;i f<={newbase=(ElemType*)realloc,+LISTINCREMENT)*sizeof(ElemType));=newbase;+=LISTINCREMENT;}q=&[i-1]);f or(p=&[]);p>=q;p--)*(p+1)=*p;*q=e;++;r eturn OK;}void MergeList(SqList La,SqList Lb,SqList &Lc){i nt i,j,k,La_len,Lb_len,ai,bj;i=j=1;k=0;I nitList_Sq(Lc);L a_len=ListLength(La);L b_len=ListLength(Lb);w hile((i<=La_len)&&(j<=Lb_len)){GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ListInsert_Sq(Lc,++k,ai);i++;}else{ListInsert_Sq(Lc,++k,bj);j++;}}w hile(i<=La_len){GetElem(La,i++,ai);ListInsert_Sq(Lc,++k,ai);}w hile(j<=Lb_len){GetElem(Lb,j++,bj);ListInsert_Sq(Lc,++k,bj);}L oad_Sq(Lc);}int main(){i nt an,bn,i,e;S qList La,Lb,Lc;I nitList_Sq(La);s canf("%d",&an);f or(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(La,i,e);}p rintf("List A:");L oad_Sq(La);I nitList_Sq(Lb);s canf("%d",&bn);f or(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(Lb,i,e);}p rintf("List B:");L oad_Sq(Lb);p rintf("List C:");M ergeList(La,Lb,Lc);r eturn 0;}333333#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));i f(!{printf("NO1");return ERROR;}=0;=LIST_INIT_SIZE;r eturn OK;}int Load_Sq(SqList &L){i nt i;i f(!{printf("This List is empty!\n");return ERROR;}e lse{for(i=0;i<;i++)printf("%d ",[i]);}p rintf("\n");r eturn OK;}int ListInsert_Sq(SqList &L,int i,int e){E lemType *newbase,*p,*q;i f>={newbase=(ElemType*)realloc,+LISTINCREMENT)*sizeof(ElemType));if(!newbase){printf("NO2");return ERROR;}=newbase;+=LISTINCREMENT;}q=&[i-1]);f or(p=&[]);p>=q;p--)*(p+1)=*p;*q=e;++;r eturn OK;}int swap(SqList &L,int n){i nt i,j,temp;f or(i=0,j=n-1;j>i;i++,j--) {temp=[i];[i]=[j];[j]=temp;}r eturn OK;}int main(){S qList T;i nt n,i;E lemType x;s canf("%d",&n);I nitList_Sq(T);f or(i=1;i<n+1;i++){scanf("%d",&x);ListInsert_Sq(T,i,x); }p rintf("The List is:");L oad_Sq(T);s wap(T,n);p rintf("The turned List is:"); L oad_Sq(T);r eturn 0;}444444#include<>#include<>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{i nt data;s truct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){L inkList p,q;i nt i;E lemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;f or(i=0;i<n;i++){scanf("%d",&e);p=(LinkList)malloc(sizeof(LNode));p->data=e;p->next=q->next;q->next=p;q=q->next;}r eturn OK;}int LoadLink_L(LinkList &L){L inkList p=L->next;i f(!p)printf("The List is empty!");e lse{printf("The LinkList is:");while(p){printf("%d ",p->data);p=p->next;}}p rintf("\n");r eturn OK;}int LinkInsert_L(LinkList &L,int i,ElemType e) {L Node *p=L,*s;i nt j=0;w hile(p&&j<i-1){p=p->next;j++;}i f(!p||j>i-1)return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;r eturn OK;}int LinkDelete_L(LinkList &L,int i,ElemType &e) {L Node *p=L,*q;i nt j=0;w hile(p->next&&j<i-1){p=p->next;j++;}i f(!(p->next)||j<i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;f ree(q);r eturn OK;}int main(){L inkList T;i nt a,n,i;E lemType x,e;p rintf("Please input the init size of the linklist:\n");s canf("%d",&n);p rintf("Please input the %d element of the linklist:\n",n);i f(CreateLink_L(T,n)){printf("A Link List Has Created.\n");LoadLink_L(T);}w hile(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1:scanf("%d%d",&i,&x);if(!LinkInsert_L(T,i,x))printf("Insert Error!\n");elseprintf("The Element %d is Successfully Inserted!\n",x);break;case 2:scanf("%d",&i);if(!LinkDelete_L(T,i,e))printf("Delete Error!\n");elseprintf("The Element %d is Successfully Deleted!\n",e);break;case 3:LoadLink_L(T);break;case 0:return 1;}}}555555#include<>#include<>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{i nt data;s truct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){L inkList p,q;i nt i;E lemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;f or(i=0;i<n;i++){scanf("%d",&e);p=(LinkList)malloc(sizeof(LNode));p->data=e;p->next=q->next;q->next=p;q=q->next;}r eturn OK;}int LoadLink_L(LinkList &L){L inkList p=L->next;i f(!p)printf("The List is empty!");e lse{while(p){printf("%d ",p->data);p=p->next;}}p rintf("\n");r eturn OK;}void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc) {L inkList pa,pb,pc;p a=La->next;p b=Lb->next;L c=pc=La;w hile(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}p c->next=pa?pa:pb;f ree(Lb);}int main(){L inkList La,Lb,Lc;i nt n;s canf("%d",&n);C reateLink_L(La,n);p rintf("List A:");L oadLink_L(La);s canf("%d",&n);C reateLink_L(Lb,n);p rintf("List B:");L oadLink_L(Lb);M ergeList_L(La,Lb,Lc);p rintf("List C:");L oadLink_L(Lc);r eturn 0;}666666#include<>#include<>#define OK 1#define ERROR 0#define ElemType inttypedef struct LNode{i nt data;s truct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n) {L inkList p,q;i nt i;E lemType e;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;q=(LinkList)malloc(sizeof(LNode)); q=L;f or(i=0;i<n;i++){scanf("%d",&e);p=(LinkList)malloc(sizeof(LNode));p->data=e;p->next=q->next;q->next=p;q=q->next;}r eturn OK;}int LoadLink_L(LinkList &L){L inkList p=L->next;i f(!p)printf("The List is Empty!");e lsewhile(p){printf("%d ",p->data);p=p->next;}p rintf("\n");r eturn OK;}int inversion(LinkList &L){L inkList p=L->next,q;L->next=NULL;w hile(p){q=p->next;p->next=L->next;L->next=p;p=q;}r eturn OK;}int main(){L inkList T;i nt n;s canf("%d",&n);C reateLink_L(T,n);p rintf("The List is:");L oadLink_L(T);i nversion(T);p rintf("The turned List is:");L oadLink_L(T);r eturn 0;}实验二实验二实验二实验二实验二实验二实验二实验二实验二实验二实验二实验二实验二#include<>#include<>#include<>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{S ElemType *base;S ElemType *top;i nt stacksize;};Status InitStack(SqStack &S){=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));i f(!return ERROR;=;=STACK_INIT_SIZE;r eturn OK;}Status Push(SqStack &S,SElemType e){i f {=(SElemType*)realloc,+STACKINCREMENT)*sizeof(SElemType));ifreturn ERROR;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}Status Pop(SqStack &S,SElemType &e) {i f==return ERROR;e=*;r eturn OK;}Status GetTop(SqStack S,SElemType &e) {i f==return ERROR;e=*;r eturn OK;}int StackLength(SqStack S){i nt i=0;w hile!={i++;;}r eturn i;}Status StackTraverse(SqStack S){S ElemType *p=(SElemType*)malloc(sizeof(SElemType)); p=;i f==printf("The Stack is Empty!");e lse{printf("The Stack is:");p--;;while(p!={printf("% d",*p);p--;}}p rintf("\n");r eturn OK;}int main(){i nt a;S qStack S;S ElemType x,e;i f(InitStack(S))printf("A Stack Has Created.\n");w hile(1){printf("1:Push\n2:Pop\n3:Get the Top\n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1:scanf("%d",&x);if(!Push(S,x))printf("Push Error!\n");elseprintf("The Element %d is Successfully Pushed!\n",x);break;case 2:if(!Pop(S,e))printf("Pop Error!\n");elseprintf("The Element %d is Successfully Poped!\n",e);break;case 3:if(!GetTop(S,e))printf("GetTop Error!\n");elseprintf("The Top Element is %d!\n",e);break;case 4:printf("The Length of the Stack is %d!\n",StackLength(S));break;case 5:StackTraverse(S);break;case 0:return 1;}}222222#include<>#include<>#define ERROR 0#define OK 1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{S ElemType *base;S ElemType *top;i nt stacksize;};Status InitStack(SqStack &S){=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));i f(!return ERROR;=;=STACK_INIT_SIZE;r eturn OK;}Status Push(SqStack &S,SElemType e)i f {=(SElemType*)realloc,+STACKINCREMENT)*sizeof(SElemType));ifreturn ERROR;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}Status Pop(SqStack &S,SElemType &e){i f==return ERROR;e=*;r eturn OK;}Status StackEmpty(SqStack &S){i f==return 0;e lsereturn 1;}int main(){i nt N,e;I nitStack(S);s canf("%d",&N);w hile(N){Push(S,N%8);N=N/8;}w hile(StackEmpty(S)){Pop(S,e);printf("%d",e);}r eturn 0;}333333typedef char SElemType;#include<>#include<>#include<>#include<>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10 #define STACKINCREMENT 2{S ElemType *base;S ElemType *top;i nt stacksize;};Status InitStack(SqStack &S){=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));i f(!return 0;=;=STACK_INIT_SIZE;r eturn OK;}Status StackEmpty(SqStack S){i f==return TRUE;e lsereturn FALSE;}Status Push(SqStack &S,SElemType e){i f {=(SElemType*)realloc,+STACKINCREMENT)*sizeof(SElemType));if(!return 0;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}Status Pop(SqStack &S,SElemType &e) {i f==return ERROR;e=*;r eturn OK;}void check(){SqStack s;SElemType ch[80],*p,e;if(InitStack(s)){gets(ch);p=ch;while(*p)switch(*p){case '(':case '[':Push(s,*p++);break;case ')':case ']':if(!StackEmpty(s)){Pop(s,e);if(*p==')'&&e!='('||*p==']'&&e!='['){printf("isn't matched pairs\n");return ;}else{p++ ;break;}}else{printf("lack of left parenthesis\n");return ;}default: p++;}if(StackEmpty(s))printf("matching\n");elseprintf("lack of right parenthesis\n");}}int main(){c heck();r eturn 1;}444444typedef char SElemType;#include<>#include<>#include<>#include<>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2struct SqStack{S ElemType *base;S ElemType *top;i nt stacksize;};FILE *fp;Status InitStack(SqStack &S){=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));i f(!return 0;=;=STACK_INIT_SIZE;r eturn OK;}Status StackEmpty(SqStack S){i f==return TRUE;e lsereturn FALSE;}Status ClearStack(SqStack &S){=;r eturn OK;}Status DestroyStack(SqStack &S){f ree;=NULL;=NULL;=0;r eturn OK;}Status Push(SqStack &S,SElemType e) {i f {=(SElemType*)realloc,+STACKINCREMENT)*sizeof(SElemType));if(!return 0;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}Status Pop(SqStack &S,SElemType &e){i f==return ERROR;e=*;r eturn OK;}Status StackTraverse(SqStack S,Status(*visit)(SElemType)){w hile>visit(*++);p rintf("\n");r eturn OK;}Status visit(SElemType c){p rintf("%c",c);r eturn OK;}void LineEdit(){S qStack s;c har ch,c;i nt n,i;I nitStack(s);s canf("%d",&n);c h=getchar();f or(i=1;i<=n;i++){ch=getchar();while(ch!='\n'){switch(ch){case '#': Pop(s,c);break;case '@': ClearStack(s);break;default:Push(s,ch);}ch=getchar();}StackTraverse(s,visit);ClearStack(s);}D estroyStack(s);}int main()L ineEdit();r eturn 1;}555555#include<>#include<>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int Status;struct SqStack_T{c har *base;c har *top;i nt stacksize;};struct SqStack_N{i nt *base;i nt *top;i nt stacksize;};Status InitStack_T(SqStack_T &S){=(char*)malloc(STACK_INIT_SIZE*sizeof(char));return ERROR;=;=STACK_INIT_SIZE;r eturn OK;}Status InitStack_N(SqStack_N &S){=(int*)malloc(STACK_INIT_SIZE*sizeof(int));i f(!return ERROR;=;=STACK_INIT_SIZE;r eturn OK;}int Push_T(SqStack_T &S,char e){i f {=(char*)realloc,+STACKINCREMENT)*sizeof(char));if(!return ERROR;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}int Push_N(SqStack_N &S,int e)i f {=(int*)realloc,+STACKINCREMENT)*sizeof(int));if(!return ERROR;=+;+=STACKINCREMENT;}*++=e;r eturn OK;}int Pop_T(SqStack_T &S,char &e){i f==return ERROR;e=*;r eturn OK;}int Pop_N(SqStack_N &S,int &e){i f==return ERROR;e=*;r eturn OK;}char GetTop_T(SqStack_T S){c har e;i f==return ERROR;e=*;r eturn e;}int GetTop_N(SqStack_N S){i nt e;i f==return ERROR;e=*;r eturn e;}char Precede(char theta1,char theta2) {i nt a,b;s witch(theta1){c ase '+': a=2; break;c ase '-': a=2; break;c ase '*': a=4; break;c ase '/': a=4; break;c ase '(': a=0; break;c ase ')': a=6; break;c ase '=': a=-1; break;}s witch(theta2){c ase '+': b=1; break;c ase '-': b=1; break;c ase '*': b=3; break;c ase '/': b=3; break;c ase '(': b=6; break;c ase ')': b=0; break;c ase '=': b=-1; break;}i f(a<b)return '<';e lseif(a==b)return '=';elsereturn '>';}char precede(char e,char c){i f(c=='+'||c=='-'){if(e=='+'||e=='-'||e==')'||e=='=') return '>';elsereturn '<';}i f(c=='*'||'/'){if(e=='(')return '<';elsereturn '>';}i f(c=='('){if(e==')')return '=';elsereturn '<';}i f(c==')')return '>';i f(c=='='){if(e=='=')return '=';elsereturn '<';}}int In(char c){i f(c>='0'&&c<='9')return 1;e lsereturn 0;}int Operate(int a,char theta,int b){i nt s;s witch(theta){c ase '+': s=a+b; break;c ase '-': s=a-b; break;c ase '*': s=a*b; break;c ase '/':if(b!=0)s=a/b;elseprintf("Input error");break;}r eturn s;}int main(){i nt k=0,m,y,a,b;S qStack_T OPTR;S qStack_N OPND;c har c,theta;I nitStack_T(OPTR); Push_T(OPTR,'=');I nitStack_N(OPND); c=getchar();w hile(c!='='||GetTop_T(OPTR)!='=') {if(In(c)){m=c-'0';if(k==1){Pop_N(OPND,y);y=m+y*10;Push_N(OPND,y);k=1;c=getchar();}else{y=m;Push_N(OPND,y);c=getchar();k=1;}}else{k=0;switch(Precede(GetTop_T(OPTR),c)){case '<': Push_T(OPTR,c); c=getchar(); break;case '=': Pop_T(OPTR,c); c=getchar(); break;case '>':Pop_T(OPTR,theta);Pop_N(OPND,b);Pop_N(OPND,a);Push_N(OPND,Operate(a,theta,b));break;}}}p rintf("%d",GetTop_N(OPND));r eturn 0;}实验三实验三实验三实验三实验三实验三实验三实验三实验三实验三实验三实验三实验三#include<>#include<>#define OK 1#define ERROR 0typedef int Status;typedef int QElemType;#define MAXQSIZE 100typedef struct{Q ElemType *base;i nt front;i nt rear;}SqQueue;Status InitQueue(SqQueue &Q){=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));i f(!return ERROR;==0;r eturn OK;Status EnQueue(SqQueue &Q,QElemType e) {i f(+1)%MAXQSIZE==return ERROR;[]=e;=+1)%MAXQSIZE;r eturn OK;}Status DeQueue(SqQueue &Q,QElemType &e) {i f==return ERROR;e=[];=+1)%MAXQSIZE;r eturn OK;}Status GetHead(SqQueue Q,QElemType &e) {i f==return ERROR;e=[];r eturn OK;}int QueueLength(SqQueue Q){r eturn QueueTraverse(SqQueue Q)i nt i;i=;i f==printf("The Queue is Empty!");e lse{printf("The Queue is:");while(i!={printf("% d",[i]);i=i+1;}}p rintf("\n");r eturn OK;}int main(){i nt a;S qQueue S;Q ElemType x,e;i f(InitQueue(S))printf("A Queue Has Created.\n");w hile(1){printf("1:Enter \n2:Delete \n3:Get the Front \n4:Return the Length of the Queue\n5:Load the Queue\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d",&x);if(!EnQueue(S,x))printf("Enter Error!\n");elseprintf("The Element %d is Successfully Entered!\n",x);break;case 2: if(!DeQueue(S,e))printf("Delete Error!\n");elseprintf("The Element %d is Successfully Deleted!\n",e);break;case 3: if(!GetHead(S,e))printf("Get Head Error!\n");elseprintf("The Head of the Queue is %d!\n",e);break;case 4: printf("The Length of the Queue is %d!\n",QueueLength(S));break;case 5: QueueTraverse(S);break;case 0: return 1;}}}222222#include<>#include<>#define OK 1#define ERROR 0typedef int Status;typedef int QElemType;#define MAXQSIZE 100typedef struct{Q ElemType *base;i nt front;i nt rear;}SqQueue;Status InitQueue(SqQueue &Q){=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));i f(!return ERROR;==0;r eturn OK;}Status EnQueue(SqQueue &Q,QElemType e){i f(+1)%MAXQSIZE==return ERROR;[]=e;=+1)%MAXQSIZE;r eturn OK;}Status DeQueue(SqQueue &Q,QElemType &e){i f==return ERROR;e=[];=+1)%MAXQSIZE;r eturn OK;}Status GetHead(SqQueue Q,QElemType &e) {i f==return ERROR;e=[];r eturn OK;}int QueueLength(SqQueue Q){r eturn QueueTraverse(SqQueue Q){i nt i;i=;i f==printf("The Queue is Empty!");e lse{printf("The Queu is:");while(i!={printf("%d",[i]);i=(i+1)%MAXQSIZE;}}p rintf("\n");r eturn OK;}int main(){i nt i,a;S qQueue S;i nt p,q,e,r;f loat t,s=0;I nitQueue(S);s canf("%d",&a);g etchar();f or(i=1;i<=a*2;i++){scanf("%d",&e);getchar();EnQueue(S,e);}p=[];w hile>{q=p+[+1];DeQueue(S,e);DeQueue(S,e);if==break;。
华南农业大学数据结构上机答案实验
华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈,并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。
请将下#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef int SElemType; // 定义栈元素类型typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK 等struct SqStack{SElemType *base; // 在栈构造之前和销毁之后,base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间,以元素为单位}; // 顺序栈Status InitStack(SqStack &S){// 构造一个空栈S,该栈预定义大小为STACK_INIT_SIZE// 请补全代码S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEl emType));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){// 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){// 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR // 请补全代码if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){// 返回栈S的元素个数// 请补全代码return S.top-S.base;}Status StackTraverse(SqStack S){// 从栈顶到栈底依次输出栈中的每个元素SElemType *p = (SElemType *)malloc(sizeof(SElemType));p = S.top ; //请填空if(S.top==S.base)printf("The Stack is Empty!"); //请填空else{printf("The Stack is: ");p--;while(p>=S.base) //请填空{printf("%d ", *p);p--; //请填空}}printf("\n");return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功,请填空{printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d", &x);if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法,请填空else printf("The Element %d is Successfully Pushed!\n", x); break;case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法,请填空else printf("The Element %d is Successfully Poped!\n", e); break;case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top 是否合法,请填空else printf("The Top Element is %d!\n", e);break;case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列,并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。
数据结构(C语言版)习题及答案第四章
数据结构(C语言版)习题及答案第四章习题4.1选择题1、空串与空格串是(B)。
A、相同B、不相同C、不能确定2、串是一种特殊的线性表,其特殊性体现在(B)。
A、可以顺序存储B、数据元素是一个字符C、可以链式存储D、数据元素可以是多个字符3、设有两个串p和q,求q在p中首次出现的位置的操作是(B)。
A、连接B、模式匹配C、求子串D、求串长4、设串1=“ABCDEFG”,2=“PQRST”函数trconcat(,t)返回和t串的连接串,trub(,i,j)返回串中从第i个字符开始的、由连续j 个字符组成的子串。
trlength()返回串的长度。
则trconcat(trub(1,2,trlength(2)),trub(1,trlength(2),2))的结果串是(D)。
A、BCDEFB、BCDEFGC、BCPQRSTD、BCDEFEF5、若串=“oftware”,其子串个数是(B)。
A、8B、37C、36D、94.2简答题1、简述空串与空格串、主串与子串、串名与串值每对术语的区别?答:空串是指长度为0的串,即没有任何字符的串。
空格串是指由一个或多个空格组成的串,长度不为0。
子串是指由串中任意个连续字符组成的子序列,包含子串的串称为主串。
串名是串的一个名称,不指组成串的字符序列。
串值是指组成串的若干个字符序列,即双引号中的内容。
2、两个字符串相等的充要条件是什么?答:条件一是两个串的长度必须相等条件二是串中各个对应位置上的字符都相等。
3、串有哪几种存储结构?答:有三种存储结构,分别为:顺序存储、链式存储和索引存储。
4、已知两个串:1=”fgcdbcabcadr”,2=”abc”,试求两个串的长度,判断串2是否是串1的子串,并指出串2在串1中的位置。
答:(1)串1的长度为14,串2的长度为3。
(2)串2是串1的子串,在串2中的位置为9。
5、已知:1=〃I’matudent〃,2=〃tudent〃,3=〃teacher〃,试求下列各操作的结果:trlength(1);答:13trconcat(2,3);答:”tudentteachar”trdelub(1,4,10);答:I’m6、设1=”AB”,2=”ABCD”,3=”EFGHIJK,试画出它们在各种存储结构下的结构图。
数据结构上机实验答案
数据结构上机实验答案(总19页)-CAL-FENGHAI.-(YICAI)-Company One1-CAL-本页仅作为文档封面,使用请直接删除《数据结构实验指导书》答案实验一:1、请编写函数int fun(int *a, int *b),函数的功能是判断两个指针a和b所指存储单元的值的符号是否相同;若相同函数返回1,否则返回0。
这两个存储单元中的值都不为0。
在主函数中输入2个整数、调用函数fun、输出结果。
#include <>int fun(int *a, int *b){if (*a*(*b)>0) return(1);else return(0);}main(){int x,y;scanf("%d%d",&x,&y);if (fun(&x,&y)) printf("yes\n");else printf("no");}2、计算1+2+3+……+100,要求用指针进行设计。
即设计函数int fun(int *n)实现求1+2+3+……+*n,在主函数中输入、调用、输出结果。
#include <>int fun(int *n){int i,sum=0;for (i=1;i<=*n;i++)sum+=i;return(sum);}main(){int x,sum;scanf("%d",&x);printf("the sum is %d\n",fun(&x));}3、函数的功能是求数组a中最大数的位置(位序号)。
在主函数中输入10个整数、调用函数fun、输出结果。
#define N 10#include <>void input(int *a,int n){int i;for (i=0;i<n;i++)scanf("%d",a+i); /*scanf("%d",&a[i]);*/}int fun(int *a,int n){int i,*max;max=a;for (i=1;i<n;i++)if (a[i]>*max) max=a+i;return(max-a);}main(){int a[N],maxi;input(a,N);maxi=fun(a,N);printf("\n the max position is %d\n",maxi);}4、请编写函数fun(int *a,int n, int *odd, int *even),函数的功能是分别求出数组a中所有奇数之和和所有偶数之和。
数据结构课后习题答案-完整版
数据结构课后习题答案-完整版下面是《数据结构课后习题答案-完整版》的内容:---第一章:数组1. 题目:给定一个整数数组,判断是否存在两个元素之和等于目标值。
答案:使用双指针法,首先将数组排序,然后设置左指针指向数组头部,右指针指向数组尾部。
如果左指针和右指针指向的元素之和小于目标值,则左指针右移;如果大于目标值,则右指针左移;如果等于目标值,则找到了两个元素之和等于目标值的情况。
2. 题目:给定一个整数数组和一个目标值,找出数组中和为目标值的两个数的下标。
答案:使用哈希表,在遍历数组的过程中,将每个元素的值和下标存储在哈希表中。
遍历到当前元素时,检查目标值与当前元素的差值是否在哈希表中,如果存在,则找到了两个数的下标。
---第二章:链表1. 题目:给定一个链表,判断链表中是否存在环。
答案:使用快慢指针法,定义两个指针,一个指针每次向前移动一个节点,另一个指针每次向前移动两个节点。
如果存在环,则两个指针必定会相遇。
2. 题目:给定一个链表,删除链表的倒数第N个节点。
答案:使用双指针法,定义两个指针,一个指针先移动N个节点,然后两个指针同时向前移动,直到第一个指针到达链表尾部。
此时第二个指针指向的节点即为要删除的节点。
---第三章:栈和队列1. 题目:设计一个栈,使得可以在常数时间内获取栈中的最小元素。
答案:使用辅助栈来保存当前栈中的最小元素。
每次压栈操作时,将当前元素与辅助栈的栈顶元素比较,只有当前元素较小才将其压入辅助栈。
2. 题目:设计一个队列,使得可以在常数时间内获取队列中的最大元素。
答案:使用双端队列来保存当前队列中的最大值。
每次入队操作时,将当前元素与双端队列的末尾元素比较,只有当前元素较大才将其压入双端队列。
---第四章:树和二叉树1. 题目:给定一个二叉树,判断它是否是平衡二叉树。
答案:通过递归遍历二叉树的每个节点,计算每个节点的左子树高度和右子树高度的差值。
如果任意节点的差值大于1,则该二叉树不是平衡二叉树。
数据结构课后答案第3章
第 3 章特殊线性表——栈、队列和串2005-07-14第 3 章特殊线性表——栈、队列和串课后习题讲解1. 填空⑴设有一个空栈,栈顶指针为1000H,现有输入序列为1、2、3、4、5,经过push,push,pop,push,pop,push,push后,输出序列是(),栈顶指针为()。
【解答】23,1003H⑵栈通常采用的两种存储结构是();其判定栈空的条件分别是(),判定栈满的条件分别是()。
【解答】顺序存储结构和链接存储结构(或顺序栈和链栈),栈顶指针top= -1和top=NULL,栈顶指针top等于数组的长度和内存无可用空间⑶()可作为实现递归函数调用的一种数据结构。
【解答】栈【分析】递归函数的调用和返回正好符合后进先出性。
⑷表达式a*(b+c)-d的后缀表达式是()。
【解答】abc+*d-【分析】将中缀表达式变为后缀表达式有一个技巧:将操作数依次写下来,再将算符插在它的两个操作数的后面。
⑸栈和队列是两种特殊的线性表,栈的操作特性是(),队列的操作特性是(),栈和队列的主要区别在于()。
【解答】后进先出,先进先出,对插入和删除操作限定的位置不同⑹循环队列的引入是为了克服()。
【解答】假溢出⑺数组Q[n]用来表示一个循环队列,front为队头元素的前一个位置,rear为队尾元素的位置,计算队列中元素个数的公式为()。
【解答】(rear-front+n)% n【分析】也可以是(rear-front)% n,但rear-front的结果可能是负整数,而对一个负整数求模,其结果在不同的编译器环境下可能会有所不同。
⑻用循环链表表示的队列长度为n,若只设头指针,则出队和入队的时间复杂度分别是()和()。
【解答】O(1),O(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),输出二叉树叶子结点数。
数据结构全部上机实验及答案
淮海工学院数据结构实验指导书计算机软件教研室实验1线性表的抽象数据类型的实现实验目的1)掌握线性表的顺序存储结构和链式存储结构;2)熟练掌握顺序表和链表基本算法的实现;3)掌握利用线性表数据结构解决实际问题的方法和基本技巧;4)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果);5)按时提交实验报告。
实验环境计算机、C语言程序设计环境实验学时2学时,必做实验。
实验内容一、顺序表的基本操作实现实验要求:数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法(各算法边界条件和返回结果适当给出):1)创建任意整数线性表(即线性表的元素值随机在键盘上输入),长度限定在25之内;2)打印(遍历)该线性表(依次打印出表中元素值);3)在线性表中查找第i个元素,并返回其值;4)在线性表中第i个元素之前插入一已知元素;5)在线性表中删除第i个元素;6)求线性表中所有元素值(整数)之和;二、链表(带头结点)基本操作实验要求:数据元素类型ElemType取字符型char。
按照动态单循环链表结构实现如下算法(各算法边界条件适当给出):1)创建任意字符型有序(递增排序)单循环链表(即链表的字符元素随机在键盘上输入),长度限定在15之内;2)打印(遍历)该链表(依次打印出表中元素值);3)在链表中查找第i个元素,i合法返回元素值,否则,返回FALSE;4)在链表中查找与一已知字符相同的第一个结点,有则返回TRUE,否则,返回FALSE;5)在链表中按照有序方式插入一已知字符元素;6)在线性表中删除第i个结点;7)计算链表的长度。
实验步骤一、顺序表的源程序#include<stdlib.h>#include<stdio.h>#include<malloc.h>int list[25];int i,n,a,sum=0,k,l;int eleminsert;/*------------------创建函数--------------*/void initlist(){printf("Please input the total of the elems:");scanf("%d",&n);if(n>25||n<1) {printf("ERROE!");return;}printf("Please input the elems:...\n");for(i=0;i<n;i++){scanf("%d",&list[i]);}return;}/*------------------打印函数--------------*/void Print(int list[],int n){int j;for(j=0;j<n;j++)printf("%d\t",list[j]);printf("\n");return;}/*------------------查找函数------------*/int Search(int list[],int n,int m){if(m<1||m>n){printf("ERROR!\n"); return ;}else printf("The elem is %d at %d place\n",list[m-1],m); return;}/*----------------插入函数------------*/void Insert(int list[],int n,int m,int elem){int j;if(m<1||m>n){printf("ERROR!\n"); return ;}for(j=n-1;j>=m-1;i--){list[j+1]=list[j];}list[m-1]=elem;n=n+1;printf("The new list are:" );Print(list,n);return;}/*---------------删除函数-----------*/void Delete(int list[],int n,int m){int q;int j;if(m<1||m>n){printf("ERROR!\n"); return ;}j=list[m-1];for(q=m-1;q<=n;q++){list[q]=list[q+1];}printf("The new list are:");Print(list,n-1);free(j);return;}/*-------------求和函数------------*/void Sum(int list[],int n,int sum){int j;for(j=0;j<n;j++){sum=sum+list[j];}printf("The sum is :%d",sum);return;}void menu(){int j;/*------------菜单函数------------*/menulab:printf("********************** MENU ******************\n\n"); printf("Create a new int list :...................press 1\n\n"); printf("Print the whole list :....................press 2\n\n"); printf("Search by order :........................press 3\n\n"); printf("Insert the elem in the place i:...........press 4\n\n"); printf("Delete the elem by order :................press 6\n\n"); printf("Sum all elem in the list :................press 7\n\n"); printf("exit the programe :.......................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~7).....");checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/{case 1:/*创建任意整数线性表*/initlist();clrscr(); /*clear screen*/goto menulab;case 2: /*打印(遍历)该线性表*/printf("The original list is:");Print(list,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*在线性表中查找第i个元素,并返回其值*/printf("Input which LNode you want to Search(Input number):"); scanf("%d",&a);getchar();Search(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*在线性表中第i个元素之前插入一已知元素*/printf("Please input the elem's place where you want to insert"); scanf("%d",&k);printf("Input the elem which you want to insert:");scanf("%d",&eleminsert);Insert(list,n,k,eleminsert);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*在线性表中删除第i个元素*/printf("Please input the elem you want to delete:");scanf("%d",&l);n=n+1;Delete(list,n,l);n=n-1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*求线性表中所有元素值(整数)之和*/Sum(list,n,sum);printf("Press any key to continue.....");clrscr(); /*clear screen*/goto menulab;case0:/*退出程序*/printf("Press any key to continue.....");getchar();exit(0);}}void main(){void menu();menu();}二、链表(带头结点)的源程序#include<stdlib.h>#include<stdio.h>struct LNode{char elem;struct LNode* next;}*l,*p,*new;int i,a,k,n;char c,s;/*----------------创建函数-------------*/void intilist(void){l=(struct LNode *)malloc(sizeof(struct LNode));l->next=NULL;clrscr();printf("Input the total of the elems:.....");scanf("%d",&n);getchar();if(n>15)printf("Error!");for(i=n;i>0;i--){new=(struct LNode *)malloc(sizeof(struct LNode)); new->next=l->next;l->next=new;}p=l;while(p->next!=NULL) p=p->next;p->next=l;printf("Input elems:.......\n");p=l->next;for(i=1;i<=n;i++){scanf("%c",&p->elem);getchar();p=p->next;}return;}/*----------------排序函数-------------*/ void Sequence(struct LNode * l, int n) {int i;char swap,*e,*f;for(i=1;i<=n-1;i++){ p=l->next;while(p->next!=l){if(p->elem>p->next->elem) {e=&p->elem;f=&p->next->elem;swap=*e;*e=*f;*f=swap;} p=p->next;}}return;}/*----------------打印函数-------------*/void Print(struct LNode * l, int n){int i;p=l->next;for(i=1;i<=n;i++){printf("%c\t",p->elem);p=p->next;}printf("\n");return;}/*----------------查找函数-------------*/ void Locate(struct LNode * l, int n,int m) {int i;if(m>n) { printf("FALSE!\t");return; }else { p=l;for(i=1;i<=m;i++){p=p->next;}printf("The elem is:%c\n",p->elem);}return;}/*------已知字母匹配首结点查找函数------*/void LocateLNode(struct LNode * l, int n,char m){int i;p=l;for(i=1;i<=n;i++){p=p->next; if(p->elem==m) {printf("TRUE!\n");return;}} if(i>n) printf("FALSE!\n");return;}/*----------------插入函数-------------*/void Insert(struct LNode * l, int n,char m){new=(struct LNode *)malloc(sizeof(struct LNode));new->next=l->next;l->next=new;new->elem=m;n=n+1;Sequence(l,n);Print(l,n);return;}/*----------------删除函数-------------*/void Delete(struct LNode * l, int n,int m){int i;p=l;for(i=1;i<m;i++){p=p->next;}p->next=p->next->next;n=n-1;printf("The new list is:");Print(l,n);return;}/*----------------求表长函数-------------*/void Length(int n){int i;int length=0;for(i=1;i<=n+1;i++){length=length+sizeof(struct LNode);}printf("The length of the list is:%d",length);return;}/*----------------菜单函数-------------*/void menu(){int j;menulab:printf("********************** MENU ******************\n\n"); printf("Create the new list :..................press 1\n\n"); printf("Sequence the list :...................press 2\n\n"); printf("Search the Lnode by order :............press 3\n\n"); printf("Search the Lnode by elem :.............press 4\n\n"); printf("Insert the elem :......................press 5\n\n"); printf("Delete the elem by order :.............press 6\n\n"); printf("Return the length of the list :........press 7\n\n"); printf("exit the programe :....................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~7)....."); checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/switch(j){case 1:/*创建链表并输入元素*/intilist();clrscr(); /*clear screen*/goto menulab;case 2: /*排序并打印链表*/Sequence(l,n);printf("The orignal list is:\n");Print(l,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*查找第i个元素*/printf("Input which LNode you want to locate(Input number):"); scanf("%d",&a);getchar();Locate(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*查找与已知字符相同的第一个结点*/printf("Input the elem you want to search ");scanf("%c",&c);getchar();LocateLNode(l,n,c);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*插入已知字符的结点*/printf("Input the elem you want to insert:");scanf("%c",&s);getchar();Insert(l,n,s);n=n+1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*删除第i个结点*/printf("Input which one you want to delete:");scanf("%d",&k);if(k<1||k>n)printf("ERROR!");else{Delete(l,n,k);}n=n-1;getchar();clrscr(); /*clear screen*/goto menulab;case 7:/*计算链表长度*/Length(n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case0:/*退出链表程序*/printf("Press any key to continue.....");getchar();exit(0);}}/*------------------主函数---------------*/main(){void menu(void);menu();}测试数据与实验结果(可以抓图粘贴)一、顺序表程序抓图及其简要说明菜单选项如下图所示:该菜单由八个函数组成,实现八项功能。
(完整版)数据结构课后习题答案
第1章绪论1 •简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
答案:数据:是客观事物的符号表示,指所有能输入到计算机中并被计算机程序处理的符号的总称。
如数学计算中用到的整数和实数,文本编辑所用到的字符串,多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。
数据元素:是数据的基本单位,在计算机中通常作为一个整体进行考虑和处理。
在有些情况下,数据元素也称为元素、结点、记录等。
数据元素用于完整地描述一个对象,如一个学生记录,树中棋盘的一个格局(状态)、图中的一个顶点等。
数据项:是组成数据元素的、有独立含义的、不可分割的最小单位。
例如,学生基本信息表中的学号、姓名、性别等都是数据项。
数据对象:是性质相同的数据元素的集合,是数据的一个子集。
例如:整数数据对象是集合N={0,士1,士2,…},字母字符数据对象是集合C={ ‘ A', ‘ B…,‘ Z,‘ a'b ',…,‘ z ' },学生基本信息表也可是一个数据对象。
数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。
换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。
逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
存储结构:数据对象在计算机中的存储表示,也称为物理结构。
抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。
具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。
2 •试举一个数据结构的例子,叙述其逻辑结构和存储结构两方面的含义和相互关系。
答案:例如有一张学生基本信息表,包括学生的学号、姓名、性别、籍贯、专业等。
每个学生基本信息记录对应一个数据元素,学生记录按顺序号排列,形成了学生基本信息记录的线性序列。
航空工业出版社《数据结构》课后题答案
// 输入字符存入 ch //输入未结束 //输入非回车字符
// 输入字符为‘#’ //栈顶元素出栈
// 输入字符为‘@’ //栈清空
//输入其他字符直接进栈
// 输入字符为回车,直接进栈 // 栈 S 中元素出栈进入栈 T
8
课后习题答案
{ Pop (&S, &e); Push (&T, e);
// 栈顶元素出栈 // 出栈元素压入栈 T
void InsertItem (DLinkList q, ElemType item)
{
DLinkList p; p = (DLinkList) malloc (sizeof (DNode));
p -> da=ta item; p -> pri= or q;
p -> next = q -> next; q -> ne= xt p;
{
int i = 0, k = 0;
char x, theta; SeqStack OPTR IniS tack (&OPTR); Push (&OPTR, '#');
//定义运算符栈 // 初始化运算符栈
//将'#'压入栈底
while (str1[i] != '#' || GetTop (OPTR) != '#')
//算符优先关系数组
//输入字符是否属于运算符集合,如果是,返回它在数组中的位置;否则,返回-1
int Isoperator (char ch)
{
int i;
for (i = 0; i < 7; i ++)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
*/
/* maxk from the single sorted LinkList with head pointer L.*/ { LinkList p,q,pre; pre=L; while(pre->next&&pre->next->data<=mink) pre=pre->next; p=pre->next; while(p&&p->data<maxk) { q=p; p=p->next; free(q); } pre->next=p; } 21 void Inverse(SqList &L) { int i,j; ElemType p; for(i=0,j=L.length-1;i<j;i++,j--) { p=L.elem[j]; L.elem[j]=L.elem[i]; L.elem[i]= p; } } 21 void Inverse(LinkList &L) /* 对带头结点的单链表L实现就地逆置 */ { LinkList p,q,s; p=L->next; q=p->next; if(p->next!=NULL&&q->next!=NULL)
for(j=n;j>0;j--) y=x*(y+a[j]); s=y+a[0]; return(s); } 第二章 12 char Compare(SqList A, SqList B) // 比较顺序表A和B, // 返回'<', 若A<B; // '=', 若A=B; // '>', 若A>B { int i; for(i=1;i<=A.length&&i<=B.length;i++) if(A.elem[i]!=B.elem[i]) return A.elem[i]>B.elem[i]?'>':'<'; if(A.length==B.length) return '='; return A.length>B.length?'>':'<'; } 14 int Length(LinkList L) // Return the length of the linked list // whose head node is pointed by 'L' { LNode *p; int k; p=L; for(k=0;(p->next)!=NULL;p=p->next,k++); return k; } 19 void DeleteSome(LinkList &L, ElemType mink, ElemType maxk) /* Delete all the elements which value is between mink and
பைடு நூலகம்
t->next=lb; la=s; lb=t; while(s->next!=NULL && x<(i-1)) { s=s->next; x++; } if(s->next==NULL && x<(i-1)) { s=la; t=lb; la=la->next; lb=lb->next; free(s); free(t); return INFEASIBLE; } r=o=s->next; while(o!=NULL && z<len) { o=o->next; z++; } if(o==NULL || z<len) { s=la; t=lb; la=la->next; lb=lb->next; free(s); free(t); return INFEASIBLE; } while(t->next!=NULL && y<(j-1)) { t=t->next;
} i++; } for(s='A';s<='E';s++) { printf("School %c:\n",s); printf("Total score of male:%d\n",score[i].malescore); printf("Total score of female:%d\n",score[i].femalescore); printf("Total score of all:%d\n\n",score[i].totalscore); } } 19 Status Series(int ARRSIZE, int a[]) /* 求i!*2^i序列的值并依次存入长度为ARRSIZE的数组a; */ /* 若所有值均不超过MAXINT,则返回OK,否则返回OVERFLOW */ { int last,i; last=1; for (i=1;i<=ARRSIZE;i++) { a[i-1]=last*2*i; if (a[i-1]>MAXINT) return OVERFLOW; last=a[i-1]; } return OK; } 20 float Polynomial(int n, int a[], float x) /* 求一元多项式的值P(x)。 */ /* 数组a的元素a[i]为i次项的系数,i=0,...,n */ { int j,i; float y,s; y=0;
p=q->next; t->next=p; free(q); } p->coef*=p->exp; p->exp--; t=p; p=p->next; } } 13 LinkList Locate(LinkList &L, ElemType x) // If 'x' in the linked list whose head node is pointed // by 'L', then return pointer ha pointing node 'x', // otherwise return 'NULL' { LNode*p; for(p=L->next;p&&p->data!=x;p=p->next); return p; } 16 Status DeleteAndInsertSub(LinkList &la, LinkList &lb, int i, int j, int len) // la和lb分别指向两个单链表中第一个结点, */ /* 本算法是从la表中删去自第i个元素起共len个元素,*/ /* 并将它们插入到lb表中第j个元素之前, */ /* 若lb表中只有j-1个元素,则插在表尾。 */ { if(i<=0 || j<=0 || len<=0) return INFEASIBLE; LNode *s,*t,*o,*r; int x=0,y=0,z=1; s=(LinkList)malloc(sizeof(LNode)); t=(LinkList)malloc(sizeof(LNode)); s->next=la;
{ s=q->next;p->next=NULL; while(s->next) { q->next=p;p=q;q=s;s=s->next; } q->next=p;s->next=q;L->next=s; } } 31 ElemType DeleteNode(LinkList s) /* 删除指针s所指结点的前驱结点,并返回被删结点的元素值 */ { LNode *p; int e; p=s; while(p->next->next!=s) p=p->next; e=p->next->data; p->next=s; return e; } 41 void Difference(LinkedPoly &pa) /* 稀疏多项式 pa 以循环链表作存储结构, */ /* 将此链表修改成它的导函数,并释放无用结点 */ { LinkedPoly p,q,t; p=pa->next; t=pa; while(p!=pa) { if(p->exp==0) { q=p;
void Scores(ResultType *result, ScoreType *score) /* 求各校的男、女总分和团体总分, 并依次存入数组score */ /* 假设比赛结果已经储存在result[ ]数组中, */ /* 并以特殊记录 {"", male, ' ', "", 0 }(域scorce=0)*/ /* 表示结束 */ { int i=0; char s; while(result[i].sport!=NULL) { switch(result[i].schoolname) { case 'A': score[0].totalscore+=result[i].score; if(result[i].gender==male) score[0].malescore+=result[i].score; else score[0].femalescore+=result[i].score; break; case 'B': score[1].totalscore+=result[i].score; if(result[i].gender==male) score[1].malescore+=result[i].score; else score[1].femalescore+=result[i].score; break; case 'C': score[2].totalscore+=result[i].score; if(result[i].gender==male) score[2].malescore+=result[i].score; else score[2].femalescore+=result[i].score; break; case 'D': score[3].totalscore+=result[i].score; if(result[i].gender==male) score[3].malescore+=result[i].score; else score[3].femalescore+=result[i].score; break; case 'E': score[4].totalscore+=result[i].score; if(result[i].gender==male) score[4].malescore+=result[i].score; else score[4].femalescore+=result[i].score; break;