数据结构上机实验题及题解

合集下载

数据结构上机题

数据结构上机题正文：一、题目描述根据给定的需求，设计并实现一个数据结构，用于解决特定的问题。

二、问题分析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：注释说明（例如：该法律名词的定义和含义）。

华农数据结构上机实验答案

华农数据结构上机实验答案数据结构上机答案1.1顺序线性表的基本操作#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(L.length==0)printf("The List is empty!");else{printf("The List is:");for(i=0;i<L.length;i++)printf("% d",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *newbase,*q,*p;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*size of(ElemType));L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}int ListDelete_Sq(SqList &L,int i,int &e){ElemType *q,*p;if(i<1||i>L.length)return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;p++)*(p-1)=*p;L.length--;return OK;}int main(){SqList T;int a,i;ElemType e,x;if(InitList_Sq(T)){printf("A Sequence List Has Created.\n");}while(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){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;}}}1.2合并顺序表#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");return OK;}int ListLength(SqList L){return L.length;}int GetElem(SqList L,int i,ElemType &e){e=L.elem[i-1];return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *p,*q,*newbase;if(L.listsize<=L.length){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*size of(ElemType));L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--)*(p+1)=*p;*q=e;L.length++;return OK;}void MergeList(SqList La,SqList Lb,SqList &Lc){int i,j,k,La_len,Lb_len,ai,bj;i=j=1;k=0;InitList_Sq(Lc);La_len=ListLength(La);Lb_len=ListLength(Lb);while((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++;}}while(i<=La_len){GetElem(La,i++,ai);ListInsert_Sq(Lc,++k,ai);}while(j<=Lb_len){GetElem(Lb,j++,bj);ListInsert_Sq(Lc,++k,bj);}Load_Sq(Lc);}int main(){int an,bn,i,e;SqList La,Lb,Lc;InitList_Sq(La);scanf("%d",&an);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(La,i,e);}printf("List A:");Load_Sq(La);InitList_Sq(Lb);scanf("%d",&bn);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(Lb,i,e);}printf("List B:");Load_Sq(Lb);printf("List C:");MergeList(La,Lb,Lc);return 0;}1.3顺序表逆置#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem){printf("NO1");return ERROR;}L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(!L.length){printf("This List is empty!\n");return ERROR;}else{for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){ElemType *newbase,*p,*q;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*size of(ElemType));if(!newbase){printf("NO2");return ERROR;}L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--)*(p+1)=*p;*q=e;L.length++;return OK;}int swap(SqList &L,int n){int i,j,temp;for(i=0,j=n-1;j>i;i++,j--){temp=L.elem[i];L.elem[i]=L.elem[j];L.elem[j]=temp;}return OK;}int main(){SqList T;int n,i;ElemType x;scanf("%d",&n);InitList_Sq(T);for(i=1;i<n+1;i++){scanf("%d",&x);ListInsert_Sq(T,i,x);}printf("The List is:");Load_Sq(T);swap(T,n);printf("The turned List is:");Load_Sq(T);return 0;}1.4链式线性表的基本操作#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{printf("The LinkList is:");while(p){printf("%d ",p->data);p=p->next;}}printf("\n");return OK;}int LinkInsert_L(LinkList &L,int i,ElemType e) {LNode *p=L,*s;int j=0;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}int LinkDelete_L(LinkList &L,int i,ElemType &e){LNode *p=L,*q;int j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!(p->next)||j<i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}int main(){LinkList T;int a,n,i;ElemType x,e;printf("Please input the init size of the linklist:\n");scanf("%d",&n);printf("Please input the %d element of the linklist:\n",n);if(CreateLink_L(T,n)){printf("A Link List Has Created.\n");LoadLink_L(T);}while(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;}}}1.5合并链表#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{while(p){printf("%d ",p->data);p=p->next;}}printf("\n");return OK;}void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc) {LinkList pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;free(Lb);}int main(){LinkList La,Lb,Lc;int n;scanf("%d",&n);CreateLink_L(La,n);printf("List A:");LoadLink_L(La);scanf("%d",&n);CreateLink_L(Lb,n);printf("List B:");LoadLink_L(Lb);MergeList_L(La,Lb,Lc);printf("List C:");LoadLink_L(Lc);return 0;}1.6线性链表逆置#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is Empty!");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");return OK;}int inversion(LinkList &L){LinkList p=L->next,q;L->next=NULL;while(p){q=p->next;p->next=L->next;L->next=p;p=q;}return OK;}int main(){LinkList T;int n;scanf("%d",&n);CreateLink_L(T,n);printf("The List is:");LoadLink_L(T);inversion(T);printf("The turned List is:");LoadLink_L(T);return 0;}2.1顺序栈的基本操作#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{SElemType *base;SElemType *top;int stacksize;};Status InitStack(SqStack &S){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){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*si zeof(SElemType));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){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){if(S.top==S.base)return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){int i=0;while(S.top!=S.base){i++;S.top--;}return i;}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--;S.base--;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");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;}}}2.2循环队列的基本操作#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int QElemType;#define MAXQSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));if(!Q.base)return ERROR;Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}Status GetHead(SqQueue Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];return OK;}int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE; }Status QueueTraverse(SqQueue Q){int i;i=Q.front;if(Q.front==Q.rear)printf("The Queue is Empty!");else{printf("The Queue is:");while(i!=Q.rear){printf("% d",Q.base[i]);i=i+1;}}printf("\n");return OK;}int main(){int a;SqQueue S;QElemType x,e;if(InitQueue(S))printf("A Queue Has Created.\n");while(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;}}}2.3栈的应用——进制转换#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{SElemType *base;SElemType *top;int stacksize;};Status InitStack(SqStack &S){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){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*si zeof(SElemType));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){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackEmpty(SqStack &S){if(S.top==S.base)return 0;elsereturn 1;}int main(){int N,e;SqStack S;InitStack(S);scanf("%d",&N);while(N){Push(S,N%8);N=N/8;}while(StackEmpty(S)){Pop(S,e);printf("%d",e);}return 0;}2.4括号匹配检验typedef char SElemType;#include<malloc.h>#include<stdio.h>#include<math.h>#include<process.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2struct SqStack{SElemType *base;SElemType *top;int stacksize;};Status InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base)return 0;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){if(S.top==S.base)return TRUE;elsereturn FALSE;}Status Push(SqStack &S,SElemType e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*si zeof(SElemType));if(!S.base)return 0;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return 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(){check();return 1;}2.5行编辑程序typedef char SElemType;#include<malloc.h>#include<stdio.h>#include<math.h>#include<process.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2struct SqStack{SElemType *base;SElemType *top;int stacksize;};FILE *fp;Status InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base)return 0;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){if(S.top==S.base)return TRUE;elsereturn FALSE;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status DestroyStack(SqStack &S){free(S.base);S.base=NULL;S.top=NULL;S.stacksize=0;return OK;}Status Push(SqStack &S,SElemType e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*si zeof(SElemType));if(!S.base)return 0;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S,Status(*visit)(SElemType)) {while(S.top>S.base)visit(*S.base++);printf("\n");return OK;}Status visit(SElemType c){printf("%c",c);return OK;}void LineEdit(){SqStack s;char ch,c;int n,i;InitStack(s);scanf("%d",&n);ch=getchar();for(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);}DestroyStack(s);}int main(){LineEdit();return 1;}2.6表达式求值#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int Status;struct SqStack_T{char *base;char *top;int stacksize;};struct SqStack_N{int *base;int *top;int stacksize;};Status InitStack_T(SqStack_T &S){S.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status InitStack_N(SqStack_N &S){S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(int));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}int Push_T(SqStack_T &S,char e){if(S.top-S.base>=S.stacksize){S.base=(char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof( char));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}int Push_N(SqStack_N &S,int e){if(S.top-S.base>=S.stacksize){S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(i nt));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}int Pop_T(SqStack_T &S,char &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}int Pop_N(SqStack_N &S,int &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}char GetTop_T(SqStack_T S){char e;if(S.top==S.base)return ERROR;e=*(S.top-1);return e;}int GetTop_N(SqStack_N S){int e;if(S.top==S.base)return ERROR;e=*(S.top-1);return e;}char Precede(char theta1,char theta2) {int a,b;switch(theta1){case '+': a=2; break;case '-': a=2; break;case '*': a=4; break;case '/': a=4; break;case '(': a=0; break;case ')': a=6; break;case '=': a=-1; break;}switch(theta2){case '+': b=1; break;case '-': b=1; break;case '*': b=3; break;case '/': b=3; break;case '(': b=6; break;case ')': b=0; break;case '=': b=-1; break;}if(a<b)return '<';elseif(a==b)return '=';elsereturn '>';}char precede(char e,char c){if(c=='+'||c=='-'){if(e=='+'||e=='-'||e==')'||e=='=') return '>';elsereturn '<';}if(c=='*'||'/'){if(e=='(')return '<';elsereturn '>';}if(c=='('){if(e==')')return '=';elsereturn '<';}if(c==')')return '>';if(c=='='){if(e=='=')return '=';elsereturn '<';}}int In(char c){if(c>='0'&&c<='9')return 1;elsereturn 0;}int Operate(int a,char theta,int b){int s;switch(theta){case '+': s=a+b; break;case '-': s=a-b; break;case '*': s=a*b; break;case '/':if(b!=0)s=a/b;elseprintf("Input error");break;}return s;}int main(){int k=0,m,y,a,b;SqStack_T OPTR;SqStack_N OPND;char c,theta;InitStack_T(OPTR); Push_T(OPTR,'=');InitStack_N(OPND); c=getchar();while(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;}}}printf("%d",GetTop_N(OPND));return 0;}2.7队列的应用——银行客户平均等待时间#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0typedef int Status;typedef int QElemType;#define MAXQSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));if(!Q.base)return ERROR;Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}Status GetHead(SqQueue Q,QElemType &e){if(Q.rear==Q.front)return ERROR;e=Q.base[Q.front];return OK;}int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE; }Status QueueTraverse(SqQueue Q){int i;i=Q.front;if(Q.rear==Q.front)printf("The Queue is Empty!");else{printf("The Queu is:");while(i!=Q.rear){printf("%d",Q.base[i]);i=(i+1)%MAXQSIZE;}}printf("\n");return OK;}int main(){int i,a;SqQueue S;int p,q,e,r;float t,s=0;InitQueue(S);scanf("%d",&a);getchar();for(i=1;i<=a*2;i++){scanf("%d",&e);getchar();EnQueue(S,e);}p=S.base[S.front];while(S.rear>S.front){q=p+S.base[S.front+1];DeQueue(S,e);DeQueue(S,e);if(S.front==S.rear)break;r=q-S.base[S.front];if(r<0){r=0;p=S.base[S.front];continue;}s=s+r;p=q;}t=s/a;printf("%.2f\n",t);return OK;}3.1计算next值#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define MAXSTRLEN 255typedef unsigned char SString[MAXSTRLEN+1];void get_next(SString T,int next[]){int i=1,j=0;next[1]=0;while(i<T[0]){if(j==0||T[i]==T[j]){i++;j++;next[i]=j;}elsej=next[j];}}。

数据结构上机考试(含答案)

数据结构》上机练习题1、设有两个有序序列, 利用归并排序将它们排成有序表,并输出。

2、设有一有序序列, 从键盘输入一个数, 判别是否在序列中,如果在输出“YSE”;否则, 将它插入到序列中使它仍然有序, 并输出排序后的序列。

3、设有一有序序列,从键盘输入一个数,判别是否在序列中,如果不在,则输出“NO”,否则,将它从序列中删除它, 并输出删除后的序列。

4、从键盘输入一组任意数据,建立一个有序链表, 并从链头开始输出该链,使输出结果是有序的。

5、从键盘输入一组任意数据,建立一个包含所有输入数据的单向循环链表, 并从链表的任意开始, 依次输出该链表中的所有结点。

10、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中, 如果不在, 则输出“ NO“,否则, 将它从链表中删除, 并输出删除后的链表。

11、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中,如果在输出“ YSE”,否则,将它从插入到链头,并输出插入后的链表。

12、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中,如果在输出“ YSE”,否则,将它从插入到链尾,并输出插入后的链表。

13、编写栈的压栈push、弹栈pop函数, 从键盘输入一组数据,逐个元素压入堆栈, 然后再逐个从栈中弹出它们并输出14、编写栈的压栈 push 、弹栈 pop 函数,用它判别() 的匹配问题树中序遍历的结果。

树先序遍历的结果。

树后序遍历的结果。

树的总结点数。

树叶子结点数。

叉树的高度。

21、给出一个无向图的邻接矩阵 , 输出各个顶点的度。

22、给出一个有向图的邻接矩阵 , 输出各个顶点的入度与出度。

23、输入一个有序序列 , 利用折半查找来查找一个数是否在序列中出其位置 ,否则输出“ NO ”。

24、用插入排序方法对一组数据进行排序 , 并输出每趟排序的结果。

数据结构上机答案（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章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。

数据结构上机实验答案

《数据结构实验指导书》答案实验一：1、请编写函数int fun(int*a, int *b), 函数的功能是判断两个指针 a 和 b 所指存储单元的值的符号是否相同；若相同函数返回1，否则返回0。

这两个存储单元中的值都不为0。

在主函数中输入 2 个整数、调用函数fun、输出结果。

#include <stdio.h>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 <stdio.h>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 <stdio.h>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

数据结构与算法实验报告目录实验一学生成绩分析程序 (4)1.1 上机实验的问题和要求（需求分析）： (4)1.2 程序设计的基本思想，原理和算法描述： (4)1.3 调试和运行程序过程中产生的问题及采取的措施： (4)1.4 运行输出结果： (4)1.5 源程序及注释： (5)实验二线性表的基本操作 (8)2.1 上机实验的问题和要求（需求分析）： (8)2.2 程序设计的基本思想，原理和算法描述： (8)2.3 调试和运行程序过程中产生的问题及采取的措施： (8)2.4 运行输出结果： (8)2.5 源程序及注释： (8)实验三链表的基本操作 (11)3.1 上机实验的问题和要求（需求分析）： (11)3.2 程序设计的基本思想，原理和算法描述： (11)3.3 调试和运行程序过程中产生的问题及采取的措施： (11)3.4 运行输出结果： (11)3.5 源程序及注释： (11)实验四单链表综合实验 (14)4.1 上机实验的问题和要求（需求分析）： (14)4.2 程序设计的基本思想，原理和算法描述： (14)4.3 调试和运行程序过程中产生的问题及采取的措施： (14)4.4 运行输出结果： (14)4.5 源程序及注释： (14)实验五串 (19)5.1 上机实验的问题和要求（需求分析）： (19)5.2 程序设计的基本思想，原理和算法描述： (19)5.3 调试和运行程序过程中产生的问题及采取的措施： (19)5.4 运行输出结果： (19)5.5 源程序及注释： (21)实验六循环队列的实现与运算 (22)6.1 上机实验的问题和要求（需求分析）： (22)6.2 程序设计的基本思想，原理和算法描述： (22)6.3 调试和运行程序过程中产生的问题及采取的措施： (22)6.4 运行输出结果： (22)6.5 源程序及注释： (23)实验七栈子系统 (26)7.1 上机实验的问题和要求（需求分析）： (26)7.2 程序设计的基本思想，原理和算法描述： (26)7.3 调试和运行程序过程中产生的问题及采取的措施： (26)7.4 运行输出结果： (26)7.5 源程序及注释： (28)实验八树 (36)8.1 上机实验的问题和要求（需求分析）： (36)8.2 程序设计的基本思想，原理和算法描述： (39)8.3 调试和运行程序过程中产生的问题及采取的措施： (39)8.4 运行输出结果： (39)8.5 源程序及注释： (41)实验九建立哈夫曼树与哈夫曼树与码 (50)9.1 上机实验的问题和要求（需求分析）： (50)9.2 程序设计的基本思想，原理和算法描述： (50)9.3 调试和运行程序过程中产生的问题及采取的措施： (50)9.4 运行输出结果： (50)9.5 源程序及注释： (50)实验十图 (53)10.1 上机实验的问题和要求（需求分析）： (53)10.2 程序设计的基本思想，原理和算法描述： (53)10.3 调试和运行程序过程中产生的问题及采取的措施： (53)10.4 运行输出结果： (53)10.5 源程序及注释： (53)实验一学生成绩分析程序一、上机实验的问题和要求（需求分析）：【题目】设一个班有10个学生，每个学生有学号，以及数学、物理、英语、语文、体育 5 门课的成绩信息。

数据结构(含上机实训)课后题答案

quelen--;
*e =Q->elem[tmpfront];//用e返回队头元素
}
一、填空题
1．串中的元素为字符型数据
2．两个串的长度相等，并且各个对应位置的字符都相等
3．定长顺序存储，堆存储，块链存储，堆存储
4．1100
str2[k ++] = str1[i ++];
else
{
if (Isoperator (str1[i]) == -1)//如果读入字符不是操作符，则出错
return ERROR;
switch (Compare (GetTop (OPTR), str[i]))//比较操作符优先级高低
{
case '<'://读入字符优先级高于栈顶字符优先级
OPTR栈
OPND栈
当前读入字符
步骤
OPTR栈
OPND栈
当前读入字符
1
#
35
8
# － /
35 50
2
2
#
35
－
9
# － /
35 50 2
＋
3
# －
35
5
10
# －
35 25
＋
4
# －
35 5
*
11
#
10
＋
5
# － *
35 5
10
12
# ＋
10
5
6
# － *
35 5 10
/
13
# ＋
10 5
#
7
# －
break;
default:
Push(&S,ch);//输入其他字符直接进栈

兰州大学数据结构上机实验题目及答案

《数据结构》课程实习题目实习一1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。

2、设有一个单位的人员工资，有如下信息：name、department、base pay、allowance、total。

请编写能够完成上述工作的程序。

实习二1、试用分别用线性表的向量存储结构和链表存储结构来实现约瑟夫(Josephu)问题。

约瑟夫问题如下：设有n个人围坐圆桌周围。

从某个位置上的人开始从1报数，数到m的人便出列，下一个人(第m+1个)又从1报数开始，数到m的人便是第2个出列的人，依次类推，直到最后一个人出列为止，这样就可以得到一个人员排列的新次序。

例如，n=8,m=4,从第1个人数起，得到的新次序为48521376.实习三编写建立一个由单链表组织存储的整数序列的程序，链表中每个结点存储一个整型数值，以此为基础完成将整数b插入到该链表中第一个数值为a的结点之前的程序。

实习四采用llink-rlink方式存储二叉排序树，编写能够通过键盘输入建立二叉排序树，并在建立完立即在屏幕显示中序遍历结果的程序。

实习五对于给定的一个工程施工图，该图以边为单位从键盘输入，编写能够找出该图的关键路径的程序。

实习六假设有一个数据类型为整型的一维数组A，A 中的数据元素呈无序状态，编写一个采用堆排序法将A中的数据元素按由小到大进行排序的程序。

《数据结构》答案（答案仅供参考）实验一1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。

#include<stdio.h>#include<malloc.h>{char ch;struct str *next;};void main(){char tem;struct str *p,*h,*s;h=malloc(sizeof(struct str));h->next=NULL;if(h!=NULL){printf("请输入一个字符：");//scanf("%c",&tem);tem=getchar();h->ch=tem;while(tem!='$'){printf("请继续输入：");s=malloc(sizeof(struct str));if(s!=NULL){tem=getchar();//scanf("%c",&tem);s->ch=tem;}if(tem=='$')free(s);else{if(h->next==NULL)h->next=s;elsep->next=s;p=s;}}p->next=NULL;}printf("字符串逆序输出为：\n");while(h->next!='\0'){p=h;while(p->next!='\0'){p=p->next;}printf("%c",p->ch);s->next='\0';}printf("%c",h->ch);printf("\n");}2、设有一个单位的人员工资，有如下信息：name、department、 base pay、allowance、total。

数据结构上机例题及答案

习题二⒉１描述以下四个概念的区别：头指针变量，头指针，头结点，首结点（第一个结点）。

解：头指针变量和头指针是指向链表中第一个结点（头结点或首结点）的指针；在首结点之前附设一个结点称为头结点；首结点是指链表中存储线性表中第一个数据元素的结点。

若单链表中附设头结点，则不管线性表是否为空，头指针均不为空，否则表示空表的链表的头指针为空。

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) ;。

经典数据结构上机题—答案【精选文档】

数据结构上机实验题目实验一线性表的顺序存储结构实验学时 2学时背景知识：顺序表的插入、删除及应用.目的要求：1．掌握顺序存储结构的特点。

2．掌握顺序存储结构的常见算法。

实验内容1．输入一组整型元素序列，建立顺序表。

2．实现该顺序表的遍历。

3．在该顺序表中进行顺序查找某一元素,查找成功返回1，否则返回0。

4．判断该顺序表中元素是否对称，对称返回1，否则返回0。

5．实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数.6．输入整型元素序列利用有序表插入算法建立一个有序表.7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表.8。

利用该顺序结构实现循环队列的入队、出队操作。

8．编写一个主函数,调试上述算法。

＃include 〈stdio.h〉#include <stdlib。

h>＃define OVERFLOW 0＃define MAXSIZE 100typedef int ElemType；typedef struct list{ElemType elem［MAXSIZE];int length；｝Sqlist；void Creatlist(Sqlist ＆L)｛int i；printf(”请输入顺序表的长度："）; //输入一组整型元素序列，建立一个顺序表.scanf（"％d”，＆L。

length)；for(i=0；i<L。

length；i++）scanf(”%d"，&L。

elem［i］);}void printlist（Sqlist &L）//以输出的形式实现对该顺序表的遍历{int i;for（i=0；i<L.length；i++)printf("％d ”，L。

elem［i］）;printf（”\n”)；｝void Searchlist（Sqlist &L,int x) //在顺序表中进行顺序查找某一元素x，查找成功则返回其存储位置i，否则返回错误信息{int i,k=—1；for(i=0;i<L.length;i++）if(L。

数据结构上机实验题

数据结构上机实验题数据结构实验⼀线性表270。

实验⽬的：1.熟悉C语⾔的上机环境，进⼀步掌握C语⾔的结构特点。

2.掌握线性表的顺序存储结构的定义及C语⾔实现。

3.掌握线性表的链式存储结构——单链表的定义及C语⾔实现。

4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5.掌握线性表在链式存储结构——单链表中的各种基本操作。

实验内容：1.顺序线性表的建⽴、插⼊及删除。

2.链式线性表的建⽴、插⼊及删除。

实验步骤：1.建⽴含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2.利⽤前⾯的实验先建⽴⼀个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插⼊元素68。

3.建⽴⼀个带头结点的单链表，结点的值域为整型数据。

要求将⽤户输⼊的数据按尾插⼊法来建⽴相应单链表。

实现提⽰：1.由于C语⾔的数组类型也有随机存取的特点，⼀维数组的机内表⽰就是顺序结构。

因此，可⽤C语⾔的⼀维数组实现线性表的顺序存储。

在此，我们利⽤C语⾔的结构体类型定义顺序表：#define MAXSIZE 1024-可编辑修改-typedef int elemtype; /* 线性表中存放整型元素*/typedef struct{elemtype vec[MAXSIZE];int len; /* 顺序表的长度*/}sequenlist;将此结构定义放在⼀个头⽂件sqlist.h⾥，可避免在后⾯的参考程序中代码重复书写，另外在该头⽂件⾥给出顺序表的建⽴及常量的定义。

2. 注意如何取到第i个元素，在插⼊过程中注意溢出情况以及数组的下标与位序（顺序表中元素的次序）的区别。

3.单链表的结点结构除数据域外，还含有⼀个指针域。

⽤C语⾔描述结点结构如下：typedef int elemtype;typedef struct node{elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建⽴⽅法及构造新结点时指针的变化。

数据结构上机实验(两次共五题).

数据结构上机实验（两次共五题）
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问题的函数。

华南农业大学数据结构上机答案实验

华南农业大学数据结构上机答案实验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创建一个空的循环队列，并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。

创新班数据结构上机实验2016实验题IV

创新班数据结构第四次上机实验题目4：二叉树相关算法的实验验证[实验目的]验证二叉树的链接存储结构及其上的基本操作。

[实验内容及要求]1、封装链接存储的二叉树类型，使用类或结构体均可；用具体类型为例或使用模板均可。

2、实验验证如下算法的正确性、各种功能及指标：1）创建一棵二叉树，并对其初始化；2）先根、中根、后根遍历二叉树，递归和迭代两种版本实现；层次遍历二叉树；3）在二叉树中搜索给定结点的父结点；4）搜索二叉树中符合数据域条件的结点；5）从二叉树中删除给定结点及其左右子树。

3、为便于观察程序的运行结果，设计输出函以图形或表格或其它直观的形式展现、存储计算结果。

4、注意鲁棒性；测试程序时，对所有输入变量取遍各种有代表性的值。

5、为了增强程序的可读性，程序中要有适当的注释。

6、源文件提交：创建文件夹BinaryTree，将与题目相关的所有源文件放到该目录下[测试示例]****创建二叉树****=>请输入二叉树/* 自行选择输入方式，如扩展先根序列、括号表示法等；也可逐个结点插入*/=>创建成功****遍历****=>先根遍历（递归）=>中根遍历（递归）=>后根遍历（递归）=>先根遍历（迭代）=>中根遍历（迭代）=>后根遍历（迭代）=>层次遍历****查找结点及其父亲****=>请输入待查找数据=>查找成功，其父结点为*****删除子树****=>请输入结点=>删除成功，此时树的形态为****释放树****=>释放成功注：以上只是示例，可自行设计界面和交互方式，印象深刻的设计有加分。

题目5：树和森林相关算法的实验验证[实验目的]验证树和森林的基本操作。

[实验内容及要求]1、定义左儿子—右兄弟链接存储的树(森林)类型，使用类或结构体均可；用具体类型为例或使用模板均可。

2、实验验证如下算法的正确性、各种功能及指标：1）创建树和森林；2）树和森林的先根遍历的递归和迭代算法；3）树和森林的后根遍历的递归和迭代算法；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顺序线性表的基本操作#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*siz eof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(L.length==0)printf("The List is empty!");else{printf("The List is:");for(i=0;i<L.length;i++)printf("% d",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *newbase,*q,*p;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsi ze+LISTINCREMENT)*sizeof(ElemType));L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p;*q=e;++L.length;return OK;}int ListDelete_Sq(SqList &L,int i,int &e) {ElemType *q,*p;if(i<1||i>L.length)return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;p++)*(p-1)=*p;L.length--;return OK;}int main(){SqList T;int a,i;ElemType e,x;if(InitList_Sq(T)){printf("A Sequence List Has Created.\n");}while(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){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;}}}1.2合并顺序表#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*siz eof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");return OK;}int ListLength(SqList L){return L.length;}int GetElem(SqList L,int i,ElemType &e){e=L.elem[i-1];return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *p,*q,*newbase;if(L.listsize<=L.length){newbase=(ElemType*)realloc(L.elem,(L.listsi ze+LISTINCREMENT)*sizeof(ElemType));L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--) *(p+1)=*p;*q=e;L.length++;return OK;}void MergeList(SqList La,SqList Lb,SqList &Lc) {int i,j,k,La_len,Lb_len,ai,bj;i=j=1;k=0;InitList_Sq(Lc);La_len=ListLength(La);Lb_len=ListLength(Lb);while((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++;}}while(i<=La_len){GetElem(La,i++,ai);ListInsert_Sq(Lc,++k,ai);}while(j<=Lb_len){GetElem(Lb,j++,bj);ListInsert_Sq(Lc,++k,bj);}Load_Sq(Lc);}int main(){int an,bn,i,e;SqList La,Lb,Lc;InitList_Sq(La);scanf("%d",&an);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(La,i,e); }printf("List A:");Load_Sq(La);InitList_Sq(Lb);scanf("%d",&bn);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(Lb,i,e); }printf("List B:");Load_Sq(Lb);printf("List C:"); MergeList(La,Lb,Lc);return 0;}1.3顺序表逆置#include<stdio.h>#include<malloc.h>#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){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*siz eof(ElemType));if(!L.elem){printf("NO1");return ERROR;}L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(!L.length){printf("This List is empty!\n");return ERROR;}else{for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){ElemType *newbase,*p,*q;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsi ze+LISTINCREMENT)*sizeof(ElemType));if(!newbase){printf("NO2");return ERROR;}L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--) *(p+1)=*p;*q=e;L.length++;return OK;}int swap(SqList &L,int n){int i,j,temp;for(i=0,j=n-1;j>i;i++,j--) {temp=L.elem[i];L.elem[i]=L.elem[j];L.elem[j]=temp;}return OK;}int main(){SqList T;int n,i;ElemType x;scanf("%d",&n);InitList_Sq(T);for(i=1;i<n+1;i++){scanf("%d",&x);ListInsert_Sq(T,i,x);}printf("The List is:");Load_Sq(T);swap(T,n);printf("The turned List is:");Load_Sq(T);return 0;}1.4链式线性表的基本操作#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n) {LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{printf("The LinkList is:");while(p){printf("%d ",p->data);p=p->next;}}printf("\n");return OK;}int LinkInsert_L(LinkList &L,int i,ElemType e) {LNode *p=L,*s;int j=0;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}int LinkDelete_L(LinkList &L,int i,ElemType &e) {LNode *p=L,*q;int j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!(p->next)||j<i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}int main(){LinkList T;int a,n,i;ElemType x,e;printf("Please input the init size of the linklist:\n");scanf("%d",&n);printf("Please input the %d element of the linklist:\n",n);if(CreateLink_L(T,n)){printf("A Link List Has Created.\n");LoadLink_L(T);}while(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;}}}1.5合并链表#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n) {LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{while(p){printf("%d ",p->data);p=p->next;}printf("\n");return OK;}void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){LinkList pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;free(Lb);}int main(){LinkList La,Lb,Lc;int n;scanf("%d",&n);CreateLink_L(La,n);printf("List A:");LoadLink_L(La);scanf("%d",&n);CreateLink_L(Lb,n);printf("List B:");LoadLink_L(Lb);MergeList_L(La,Lb,Lc);printf("List C:");LoadLink_L(Lc);return 0;}1.6线性链表逆置#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n) {LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(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;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is Empty!");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");return OK;}int inversion(LinkList &L) {LinkList p=L->next,q;L->next=NULL;while(p){q=p->next;p->next=L->next;L->next=p;p=q;}return OK;}int main(){LinkList T;int n;scanf("%d",&n);CreateLink_L(T,n);printf("The List is:");LoadLink_L(T);inversion(T);printf("The turned List is:");LoadLink_L(T);return 0;}2.1顺序栈的基本操作#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{SElemType *base;SElemType *top;int stacksize;Status InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*s izeof(SElemType));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacks ize+STACKINCREMENT)*sizeof(SElemType));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) {if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e) {if(S.top==S.base)return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){int i=0;while(S.top!=S.base){i++;S.top--;}return i;}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--;S.base--;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");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;}}}2.2循环队列的基本操作#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int QElemType;#define MAXQSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(Q ElemType));if(!Q.base)return ERROR;Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e) {if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e) {if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}Status GetHead(SqQueue Q,QElemType &e) {if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];return OK;}int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE; }Status QueueTraverse(SqQueue Q){int i;i=Q.front;if(Q.front==Q.rear)printf("The Queue is Empty!");else{printf("The Queue is:");while(i!=Q.rear){printf("% d",Q.base[i]);i=i+1;}}printf("\n");return OK;}int main(){int a;SqQueue S;QElemType x,e;if(InitQueue(S))printf("A Queue Has Created.\n");while(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;}}}2.3栈的应用——进制转换#include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int SElemType;typedef int Status;struct SqStack{SElemType *base;SElemType *top;int stacksize;};Status InitStack(SqStack &S){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){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacks ize+STACKINCREMENT)*sizeof(SElemType));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) {if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackEmpty(SqStack &S){if(S.top==S.base)return 0;elsereturn 1;}int main(){int N,e;SqStack S;InitStack(S);scanf("%d",&N);while(N){Push(S,N%8);N=N/8;}while(StackEmpty(S)){Pop(S,e);printf("%d",e);}return 0;}2.4括号匹配检验typedef char SElemType;#include<malloc.h>#include<stdio.h>#include<math.h>#include<process.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2struct SqStack{SElemType *base;SElemType *top;int stacksize;};Status InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*s izeof(SElemType));if(!S.base)return 0;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){if(S.top==S.base)return TRUE;elsereturn FALSE;}Status Push(SqStack &S,SElemType e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacks ize+STACKINCREMENT)*sizeof(SElemType));if(!S.base)return 0;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return 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(){check();return 1;}2.5行编辑程序typedef char SElemType;#include<malloc.h>#include<stdio.h>#include<math.h>#include<process.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;#define STACK_INIT_SIZE 10#define STACKINCREMENT 2struct SqStackSElemType *base;SElemType *top;int stacksize;};FILE *fp;Status InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*s izeof(SElemType));if(!S.base)return 0;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){if(S.top==S.base)return TRUE;elsereturn FALSE;Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status DestroyStack(SqStack &S){free(S.base);S.base=NULL;S.top=NULL;S.stacksize=0;return OK;}Status Push(SqStack &S,SElemType e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacks ize+STACKINCREMENT)*sizeof(SElemType));if(!S.base)return 0;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S,Status(*visit)(SElemType)){while(S.top>S.base)visit(*S.base++);printf("\n");return OK;}。

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

2013-03-08 上机实验题
1.构建两个顺序表示的非空线性表LA和LB (数据元素为整型，其值自行确定)；
2.从线性表LA中删除第i 个元素；
3.将元素e插入到线性表LB中的第i个元素之后；
4.假设LA中不含重复的元素 (LB同)，将线性表LA和LB合并，并输出结果，要求结
果中不含重复的元素。

//构建两个顺序表（定义、初始化）
//在一个顺序表中删除指定位置的元素
//在一个顺序表中指定位置插入一个新元素
//将两个线性表LA和LB进行合并
//遍历LB, 如果其中的数据元素不在LA中，则将其插入LA，否则不予处理
//打印线性表LA
#define List_Init_Size 100
#define LISTINCREMENT 10
typedef int Status;
typedef struct {
int * elem;
int length; // 当前长度
int ListSize; // 当前分配的存储容量
}SqList;
Status Initialize_table (SqList &L) {// 初始化线性表
int i, m, data;
L.elem=(int *)malloc(List_Init_Size *sizeof(int));
if (!L.elem) { // 为线性表分配空间
printf("Overflow");
return FAILURE; }
L.ListSize=List_Init_Size; L.length=0;
printf ("Please input the size of linear table (<=%d): "+ List_Init_Size);
scanf_s("%d",&m);
for (i=0;i<m;i++) { // 依次输入线性表的数据元素
printf("Please input the NO.%d element : ", i+1);
scanf_s("%d",&data);
*(L.elem+i)=data;
L.length++;
}
return SUCCESS;
}
Status ListDelete (SqList &L, int i, int &e) {
// 从线性表中删除第i个元素，用e返回
int *p, *q;
if ((i<1) || (i>L.length)) //检查i值是否合法
return -1;
p=L.elem+i-1; // 找到删除位置
e=*p;
q=L.elem+L.length-1; //找到最后一个元素位置
for (++p; p<=q; ++p) //数据元素前移
*(p-1)=*p;
--L.length; //修改表长
return SUCCESS;
}
Status ListInsert(SqList &L, int i, int e) {
// 在线性表中第i个位置后插入元素e
int *p,*q;
if (i<0 || i>L.length) return FAILURE;
if (L.length >= L.ListSize){
p=(int*)realloc(L.elem,(L.ListSize+ListIncrement)*sizeof(int));
if (p==NULL) return FAILURE;
L.elem=p;L.ListSize+=ListIncrement;
}
q=L.elem+i; //即在第i+1个位置上插入元素e
for (p=L.elem+L.length-1;p>=q;--p)
*(p+1)=*p;
*q=e;
++L.length; // 修改表长
return SUCCESS;
}
Status MergeList (SqList &L1,SqList L2) {
// 合并线性表L1和L2
int i=0,k=L1.length;
int ai;
while (i < L2.length) { // 将第2个线性表中的元素
// 根据合并规则加入到第1个线性表中
ai = *(L2.elem + i);
if (!ExistsIn(L1, ai))
ListInsert(L1, k++, ai);
++i;
}
return OK;
}// end of function
Status PrintSq (SqList L) {
// 打印线性表的所有数据元素
int i;
printf("Allocated Memory Size=%d Length=%d ", L.ListSize, L.length);
for (i=0;i<L.length;i++)
printf("%d",L.elem[i]);
printf ("\n");
return OK;
}
Status main (void) {
int result;
SqList La, Lb;
Initialize_table (La); // 初始化线性表Initialize_table (Lb);
ListDelete (La, 3, result); // 删除元素
ListInsert (Lb, 4, 35); // 插入元素
MergeList (La, Lb); //合并线性表
PrintSq (La); // 打印线性表free (La.elem); // 释放存储空间free (Lb.elem);
return SUCCESS;
}。

数据结构 上机实验题及题解

数据结构上机题

华农数据结构上机实验答案

数据结构上机考试(含答案)

数据结构上机答案（c语言版）

数据结构上机实验

数据结构上机实验答案

数据结构完整题目及答案1

数据结构(含上机实训)课后题答案

兰州大学数据结构上机实验题目及答案

数据结构上机例题及答案

数据结构上机考核试题及答案

经典数据结构上机题—答案【精选文档】

数据结构上机实验题

数据结构上机实验(两次共五题).

中大实践考核数据结构试题和答案(上机考试)

华南农业大学数据结构上机答案实验

创新班数据结构上机实验2016实验题IV

数据结构全部上机实验及答案

华农数据结构上机实验答案

数据结构上机实验题及题解