您的位置：360文档中心› 华南农业大学数据结构实验答案

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

合集下载

2011年华南农业大学数据结构答案(A)

2011年华南农业大学数据结构答案(A)

华南农业大学期末考试答案（A 卷）2011-2012学年第 1 学期 考试科目： 数据结构 考试类型：（闭卷）考试 考试时间： 120 分钟一、选择题（本大题共 10 小题，每小题2分，共20分）二、应用题（本大题共 5 小题，每小题6分，共30分）1、参考答案：2、参考答案：（在队列的一端进入插入时，TOP 值会增加，在另一端删除，当判断TOP==MAX-1为“是”，这说明队已满。

但实际在队列的另一端还是有存储空间的，这就是“假溢出”。

）当front 0，rear=M 时，再有元素入队发生溢出，称之为“假溢出”，存储空间还有剩余。

为了改进这种状况，可以将顺序队列想象为一个首尾相接的环状空间，称之为循环队列。

“假溢出”现象和循环队列的数据结构基本上描述清楚就可以。

其中：循环队列的队空条件：front == rear队满条件：(Q.rear+1) % MAXQSIZE == Q.front 。

3、参考答案：哈夫曼树HT 的存储结构的初态 哈夫曼树HT 的存储结构的终态 I二叉树AD EB F CG H4、参考答案：ASL=(1*6+2*4+3+4)/12=1.755、参考答案：(1)一趟希尔排序：12,2,10,20,6,18,4,16,30,8,28（D=5）；(2)一趟快速排序：6,2,10,4,8,12,28,30,20,16,18。

三、程序填空题（本大题5小题，共15个空白处，每空2分，共30分，注意：每空只填一个语句）(1) L=L->next(2) q=L(3) L=p(4) low <= high(5) key==ST[mid](6) high=mid-1(7) a[i]=t(8) (i=2;i<n;i+=2)(9) (flag)(10) FALSE(11) EnQueue(Q, v)(12) DeQueue(Q, u)(13) !visited[w](14) p=p->lchild(15) p=p->rchild2四、程序设计题（本大题共2小题，每小题10分，共20分。

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

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

华农数据结构上机实验答案数据结构上机答案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];}}。

数据结构实验报告答案

数据结构实验报告答案

数据结构实验报告答案数据结构实验报告答案引言：数据结构是计算机科学中的重要概念，它涉及组织和管理数据的方法和技术。

在本次实验中，我们将研究和实践几种常见的数据结构，包括数组、链表、栈和队列。

通过这些实验，我们将深入理解数据结构的原理和应用。

一、数组数组是一种线性数据结构，它由一系列相同类型的元素组成。

数组的特点是可以通过索引来访问和修改元素，具有随机访问的能力。

在本次实验中，我们将实现一个简单的数组类，并进行一些基本操作，如插入、删除和查找。

首先，我们定义一个数组类，包含以下成员变量和方法：- size：数组的大小- elements：存储元素的数组- insert(index, element)：在指定位置插入元素- remove(index)：删除指定位置的元素- get(index)：获取指定位置的元素- search(element)：查找元素在数组中的位置通过实现上述方法，我们可以对数组进行各种操作。

例如，我们可以在数组的末尾插入一个元素，然后在指定位置删除一个元素。

我们还可以通过元素的值来查找其在数组中的位置。

二、链表链表是另一种常见的线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

链表的特点是插入和删除操作的效率较高，但随机访问的效率较低。

在本次实验中，我们将实现一个简单的单向链表，并进行一些基本操作。

首先，我们定义一个节点类，包含以下成员变量和方法：- data：节点的数据元素- next：指向下一个节点的指针然后，我们定义一个链表类，包含以下成员变量和方法：- head：链表的头节点- insert(element)：在链表的末尾插入一个节点- remove(element)：删除链表中指定的节点- search(element)：查找链表中指定元素的节点通过实现上述方法，我们可以对链表进行各种操作。

例如，我们可以在链表的末尾插入一个节点，然后删除链表中指定的节点。

数据结构实验报告-答案.doc

数据结构实验报告-答案.doc

数据结构实验报告-答案数据结构(C语言版)实验报告专业班级学号姓名实验1实验题目：单链表的插入和删除实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。

实验要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。

实验主要步骤：1、分析、理解给出的示例程序。

2、调试程序，并设计输入数据（如：bat，cat，eat，fat，hat，jat，lat，mat，#），测试程序的如下功能：不允许重复字符串的插入；根据输入的字符串，找到相应的结点并删除。

3、修改程序：（1）增加插入结点的功能。

（2）将建立链表的方法改为头插入法。

程序代码:#include“stdio.h“#include“string.h“#include“stdlib.h“#include“ctype. h“typedefstructnode//定义结点{chardata[10];//结点的数据域为字符串structnode*next;//结点的指针域}ListNode;typedefListNode*LinkList;//自定义LinkList单链表类型LinkListCreatListR1();//函数，用尾插入法建立带头结点的单链表LinkListCreatList(void);//函数，用头插入法建立带头结点的单链表ListNode*LocateNode();//函数，按值查找结点voidDeleteList();//函数，删除指定值的结点voidprintlist();//函数，打印链表中的所有值voidDeleteAll();//函数，删除所有结点，释放内存ListNode*AddNode();//修改程序：增加节点。

用头插法，返回头指针//==========主函数==============voidmain(){charch[10],num[5];LinkListhead;head=C reatList();//用头插入法建立单链表，返回头指针printlist(head);//遍历链表输出其值printf(“Deletenode(y/n):“);//输入“y“或“n“去选择是否删除结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){printf(“PleaseinputDelete_data:“);scanf(“%s“,ch);//输入要删除的字符串DeleteList(head,ch);printlist(head);}printf(“Addnode?(y/n):“);//输入“y“或“n“去选择是否增加结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){head=A ddNode(head);}printlist(head);DeleteAll(head);//删除所有结点，释放内存}//==========用尾插入法建立带头结点的单链表===========LinkListCreatListR1(void){charch[10];LinkListhead=(Li nkList)malloc(sizeof(ListNode));//生成头结点ListNode*s,*r,*pp;r=head;r->next=NULL;printf(“Input#toend“);//输入“#“代表输入结束printf(“\nPleaseinputN ode_data:“);scanf(“%s“,ch);//输入各结点的字符串while(strcmp(ch,“#“)!=0){pp=LocateNode(head,ch);//按值查找结点，返回结点指针if(pp==NULL){//没有重复的字符串，插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);r->next=s;r=s; r->next=NULL;}printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);}returnhead;//返回头指针}//==========用头插入法建立带头结点的单链表===========LinkListCreatList(void){charch[100];LinkListhead,p;head =(LinkList)malloc(sizeof(ListNode));head->next=NULL;while(1){printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);if(strcmp (ch,“#“)){if(LocateNode(head,ch)==NULL){strcpy(head->data,ch);p=(Li nkList)malloc(sizeof(ListNode));p->next=head;head=p;}}elsebreak;}retu rnhead;}//==========按值查找结点，找到则返回该结点的位置，否则返回NULL==========ListNode*LocateNode(LinkListhead,char*key){List Node*p=head->next;//从开始结点比较while(p!=NULL//扫描下一个结点returnp;//若p=NULL则查找失败，否则p指向找到的值为key的结点}//==========修改程序：增加节点=======ListNode*AddNode(LinkListhead){charch[10];ListNode*s,*pp ;printf(“\nPleaseinputaNewNode_data:“);scanf(“%s“,ch);//输入各结点的字符串pp=LocateNode(head,ch);//按值查找结点，返回结点指针printf(“ok2\n“);if(pp==NULL){//没有重复的字符串，插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);printf(“ok3\n“);s->next=head->next;head->next=s;}returnhead;}//==========删除带头结点的单链表中的指定结点=======voidDeleteList(LinkListhead,char*key){ListNode*p,*r,*q=hea d;p=LocateNode(head,key);//按key值查找结点的if(p==NULL){//若没有找到结点，退出printf(“positionerror”);exit(0);}while(q->next!=p)//p 为要删除的结点，q为p的前结点q=q->next;r=q->next;q->next=r->next;free(r);//释放结点}//===========打印链表=======voidprintlist(LinkListhead){ListNode*p=head->next;//从开始结点打印while(p){printf(“%s,“,p->data);p=p->next;}printf(“\n“);}//==========删除所有结点，释放空间===========voidDeleteAll(LinkListhead){ListNode*p=head,*r;while( p->next){r=p->next;free(p);p=r;}free(p);}实验结果：Input#toendPleaseinputNode_data:batInput#toendPleaseinputNode_data: catInput#toendPleaseinputNode_data:eatInput#toendPleaseinputNode_da ta:fatInput#toendPleaseinputNode_data:hatInput#toendPleaseinputNode_ data:jatInput#toendPleaseinputNode_data:latInput#toendPleaseinputNode _data:matInput#toendPleaseinputNode_data:#mat,lat,jat,hat,fat,eat,cat,bat ,Deletenode(y/n):yPleaseinputDelete_data:hatmat,lat,jat,fat,eat,cat,bat,Ins ertnode(y/n):yPleaseinputInsert_data:putposition:5mat,lat,jat,fat,eat,put,c at,bat,请按任意键继续...示意图：latjathatfateatcatbatmatNULLheadlatjathatfateatcatbatmatheadlatjatfateat putcatbatmatheadNULLNULL心得体会：本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。

数据结构实验题参考答案

数据结构实验题参考答案

【实验题】1．狐狸逮兔子围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须找到我，我就藏身于这十个洞中，你先到１号洞找，第二次隔１个洞（即3号洞）找，第三次隔２个洞（即6号洞）找，以后如此类推，次数不限。

”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。

问兔子究竟藏在哪个洞里？（提示：这实际上是一个反复查找线性表的过程。

）【数据描述】定义一个顺序表，用具有10个元素顺序表来表示这10个洞。

每个元素分别表示围着山顶的一个洞，下标为洞的编号。

#define LIST_INIT_SIZE 10 //线性表存储空间的初始分配量typedef struct {ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）}SqList;【算法描述】status InitList_Sq(SqList &L) {//构造一个线性表LL.elem=(ElemType )malloc(LIST_INIT_SIZE*sizeof(ElemType));If(!L.elem) return OVERFLOW; //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;} //InitList_Sqstatus Rabbit(SqList &L){ //构造狐狸逮兔子函数int current=0; //定义一个当前洞口号的记数器，初始位置为第一个洞口for(i=0;i<LIST_INIT_SIZE;i++)L.elem[i]=1; //给每个洞作标记为1，表示狐狸未进之洞L.elem[LIST_INIT_SIZE-1]=L.elem[0]=0;//首先进入第一个洞，标记进过的洞为0。

2022年华南农业大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年华南农业大学计算机科学与技术专业《数据结构与算法》科目期末试卷A(有答案)

2022年华南农业大学计算机科学与技术专业《数据结构与算法》科目期末试卷A（有答案）一、选择题1、下列说法不正确的是（）。

A.图的遍历是从给定的源点出发每个顶点仅被访问一次B.遍历的基本方法有两种：深度遍历和广度遍历C.图的深度遍历不适用于有向图D.图的深度遍历是一个递归过程2、若需在O（nlog2n）的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是（）。

A.快速排序B.堆排序C.归并排序D.直接插入排序3、单链表中，增加一个头结点是为了（）。

A.使单链表至少有一个结点B.标识表结点中首结点的位置C.方便运算的实现D.说明单链表是线性表的链式存储4、动态存储管理系统中，通常可有（）种不同的分配策略。

A.1B.2C.3D.45、最大容量为n的循环队列，队尾指针是rear，队头：front，则队空的条件是（）。

A.（rear+1）MOD n=frontB.rear=frontC.rear+1=frontD.（rear-1）MOD n=front6、若元素a，b，c，d，e，f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈操作，则不可能得到的出栈序列是（）。

7、下列选项中，不能构成折半查找中关键字比较序列的是（）。

A．500，200，450，180 B．500，450，200，180C．180，500，200，450 D．180，200，500，4508、在下述结论中，正确的有（）。

①只有一个结点的二叉树的度为0。

②二叉树的度为2。

③二叉树的左右子树可任意交换。

④深度为K的完全二叉树的结点个数小于或等于深度相同的满二叉树。

A.①②③B.⑦③④C.②④D.①④9、有关二叉树下列说法正确的是（）。

A.二叉树的度为2B.一棵二叉树的度可以小于2C.二叉树中至少有一个结点的度为2D.二叉树中任何一个结点的度都为210、就平均性能而言，目前最好的内排序方法是（）排序法。

A.起泡B.希尔插入C.交换D.快速二、填空题11、对n个记录的表r[1..n]进行简单选择排序，所需进行的关键字间的比较次数为______。

数据结构-结课实验带答案

数据结构-结课实验带答案

线性表一、顺序表建立_新1、定义顺序表存储结构2、初始化顺序表为空（InitList_Sq）3、输入顺序表数据（CreateList_Sq）4、遍历（输出）顺序表数据（TraverseList_Sq）5、销毁顺序表数据（DestroyList_Sq）例如：输入元素个数和数据如下：55 3 8 7 9程序输出为：5,3,8,7,9二、单链表的建立-前插法_新1、定义单链表存储结构2、初始化一个空的单链表L（InitList_L）3、用前插法创建单链表数据（CreateList_F）4、遍历（输出）单链表表数据（TraverseList_L）5、销毁单链表表数据（DestroyList_L）例如：输入单链表结点个数和数据如下：59 7 8 3 5程序输出为：5,3,8,7,9三、单链表的建立-后插法_ 新1、定义单链表存储结构2、初始化一个空的单链表L（InitList_L）3、用后插法创建单链表数据（CreateList_L）4、遍历单链表表数据（TraverseList_L）5、销毁单链表表数据（DestroyList_L）例如：输入元素个数和数据如下：55 3 8 7 9程序输出为：5,3,8,7,9四、顺序表的插入_新1、定义插入函数（ListInsert_Sq）2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入插入元素的位置和数据信息4、显示插入后的顺序表数据信息（TraverseList_Sq）例如：输入元素个数和数据如下：55 3 8 7 9插入元素的位置和值为：26程序输出为：5,3,8,7,9 //在输入插入位置和值之前遍历输出的线性表中的数据元素5,6,3,8,7,9模板如下：#include <iostream>#include<stdlib.h>using namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList;Status InitList_Sq(SqList *L){ //构造一个空的顺序表L}Status CreateList_Sq(SqList &L,int n){}//在此处定义顺序表插入函数ListInsert_Sqvoid TraverseList_Sq(SqList &L){}void DestroyList_Sq(SqList &L){}int main(){SqList L;int i,n,e;InitList_Sq(&L);//提示：输入元素个数：cin>>n;CreateList_Sq(L,n);TraverseList_Sq(L); //遍历输出插入前线性表数据元素//提示：在顺序表中输入新元素插入的位置和数据：cin>>i>>e;//在此处编写ListInsert_Sq函数的调用语句TraverseList_Sq(L);DestroyList_Sq(L);return 0;}五、顺序表的查找—按值进行查找_新1、定义按值查找函数（GetElem_Sq）2、在主函数中遍历输出查找前线性表中的元素3、在主函数中输入待查元素4、显示待查找元素的位置例如：输入顺序表元素个数和数据如下：55 3 8 7 9输入的待查找元素为：3程序输出结果有：5,3,8,7,9 //在查找之前遍历输出线性表中的数据元素2 //待查元素在线性表中的位置六、顺序表的查找—按序号进行查找_新1、定义按序查找函数（GetElem_Sq）2、在主函数中遍历输出查找之前线性表中的元素2、在主函数中输入待查元素在顺序表中的位序3、显示查找后的数据例如：输入顺序表元素个数和数据如下：55 3 8 7 9输入查找元素的位序为：2程序输出结果为：5,3,8,7,9 //在调用查找函数之前遍历输出的线性表中的数据元素3 //输出的待查元素的位序七、单链表的插入_新1、定义插入函数（ListInsert_L）2、在主函数中输出插入新结点之前单链表中的结点信息（TraverseList_L）3、在主函数中输入插入结点的位置和数据信息4、显示插入后的单链表数据信息（TraverseList_L）例如：输入单链表结点个数和数据如下：55 3 8 7 9结点插入的位置和值为：26程序输出为：5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息5,6,3,8,7,9 //插入新结点之后输出的单链表中的结点信息模板如下：#include <iostream>using namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data; //结点的数据域struct LNode *next; //结点的指针域} LNode, *LinkList; //LinkList为指向结构体LNode的指针类型Status InitList_L(LinkList &L){//构造一个空的单链表L}void CreateList_L(LinkList &L,int n){}//在此处定义单链表的插入函数ListInsert_Lvoid TraverseList_L(LinkList L)//依次输出单链表里的每个元素{}Status DestroyList_L(LinkList &L){}int main(){LinkList L; //用LinkList L;替换，与#include "LinkList.h"配合int n,i;ElemType e;InitList_L(L);//提示：请输入单链表的结点个数：cin>>n;CreateList_L(L,n);TraverseList_L(L);//提示：在单链表中输入结点插入的位置和数据：cin>>i>>e;//在此处调用单链表的插入函数TraverseList_L(L);DestroyList_L(L);return 0;}八、顺序表删除_新1、定义删除函数（ListDelete_Sq）2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入被删元素的位置4、显示删除后的线性表元素例如：输入顺序表元素个数和数据如下：55 3 8 7 9输入被删元素的位置：2程序输出结果为：5,3,8,7,9 //删除元素之前输出的线性表中的数据元素3 //输出的被删除元素5,8,7,9 //输出删除元素之后线性表中的数据元素九、单链表的查找-按序号查找_新1、定义按序查找函数（GetElem_Sq）2、在主函数中输出插入新结点之前单链表中的结点信息（TraverseList_L）3、在主函数中输入待查元素在单链表中的位序4、显示查找后的数据例如：输入单链表结点个数和数据如下：55 3 8 7 9输入查找结点的位序为：2程序输出结果为：5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息3 //输出该位置上的结点信息十、单链表结点的删除_ 新1、定义删除函数（ListDelete_L2、在主函数中遍历输出删除前单链表中的结点信息3、在主函数中输入被删结点的位置4、显示删除后的单链表的结点信息例如：输入单链表结点个数和数据如下：55 3 8 7 9输入被删结点的位置：2程序输出结果为：5,3,8,7,9 //删除结点之前遍历输出的单链表中的结点信息3 //输出被删除结点的结点信息5,8,7,9 //删除结点之后遍历输出的单链表中的结点信息十一、线性表的合并_新假设利用两个线性表LA和LB分别表示两个集合A和B,现要求一个新的集合A=A∪B，例如，设LA=（7 5 3 11 ），LB=（2 6 3），合并后LA=（7 5 3 11 2 6）1、定义线性表的顺序存储结构2、初始化线性表（InitList_Sq）3、创建线性表（CreateList_Sq）4、定义线性表的合并函数（unionList_Sq）,将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中，（在合并函数中，还将包含对函数ListLengtht_Sq、ListInsert_Sq、LocateElem_Sq和GetElem_Sq的调用）5、在主函数中输入两个线性表LA,LB,调用合并函数6、遍历合并后的线性表LA,并输出数据（TraverseList_Sq）例如：输入线性表LA的元素个数和数据如下：47 5 3 11输入有序表LB的元素个数和数据如下：32 6 3输出为：7,5,3,11 //输出线性表LA的数据元素2,6,3 //输出线性表LB的数据元素7,5,3,11,2,6 //输出合并后的线性表LA的数据元素十二、有序表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、定义有序表合并函数（MergeList_Sq）,将两个非递减的有序表LA和LB合并为一个新的有序表LC，且LC中的数据元素仍按值非递减有序排列（在合并函数中，还将包含对ListLengtht_Sq、ListInsert_Sq和LocateElem_Sq的调用）2、在主函数中输出LA表的数据元素（TraverseList_Sq）3、在主函数中输出LB表的数据元素（TraverseList_Sq）4、在主函数中输入两个非递减的有序表LA,LB,调用合并函数5、遍历合并后的有序表LC,并输出数据（TraverseList_Sq）例如：输入有序表LA的元素个数和数据如下：42 5 8 9输入有序表LB的元素个数和数据如下：63 4 8 10 12 20输出为：2,5,8,9 //输出LA表的数据元素3,4,8,10,12,20 //输出LB表的数据元素2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的数据元素十三、有序链表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、用后插法创建单链表数据（CreateList_L）2、定义遍历函数输出单链表数据（TraverseList_L）3、定义有序链表合并函数（MergeList_L）,将两个非递减的有序链表LA和LB合并为一个新的有序链表LC，且LC中的结点元素仍按值非递减有序排列4、在主函数中输出LA和LB表的结点信息（TraverseList_L）5、在主函数中调用合并函数（MergeList_L）6、遍历合并后的有序链表LC,并输出结点信息（TraverseList_L）例如：输入有序链表LA的结点个数和数据如下：42 5 8 9输入有序链表LB的结点个数和数据如下：63 4 8 10 12 20输出为：2,5,8,9 //输出LA表的结点信息3,4,8,10,12,20 //输出LB表的结点信息2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的结点信息栈和队列一、顺序栈的建立1.定义顺序栈的存储结构2.初始化顺序栈为空栈（InitStack_Sq）3.输入要入栈的元素个数n4.向顺序栈中压入n个元素（Push_Sq）5.将顺序栈中的元素从栈顶到栈底依次输出（StackTraverse_Sq）6.销毁顺序栈（DestroyStack_Sq）例如：54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格二、顺序栈的入栈1.定义顺序栈入栈函数（Push_Sq）2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出（StackTraverse_Sq）5.销毁顺序栈（DestroyStack_Sq）例如：56 2 8 10 99 10 8 2 6 //遍历输出时最后一个元素后有一个空格模板如下：#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack_Sq(SqStack &S) {}void DestroyStack_Sq(SqStack &S) {}//在此处定义入栈函数Push_Sqvoid StackTraverse_Sq(SqStack S) {}int main(){SqStack S;InitStack_Sq(S);int n;SElemType e;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Sq(S);DestroyStack_Sq(S);return 0;}三、顺序栈的出栈1.定义顺序栈出栈函数（Pop_Sq）2.定义求顺序栈栈长函数（StackLength_Sq）3.输入要入栈的元素个数n4.向顺序栈中压入n个元素5.将顺序栈中的元素从栈顶到栈底依次输出（StackTraverse_Sq）6.销毁顺序栈（DestroyStack_Sq）例如：42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格46 4 2 //遍历输出时最后一个元素后有一个空格83四、顺序栈栈顶元素的获取1.定义获取顺序栈栈顶元素函数（GetTop_Sq）2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出（StackTraverse_Sq）5.获取栈顶元素6.输出栈顶元素7.销毁顺序栈（DestroyStack_Sq）例如：42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8五、链栈的建立1.定义链栈的结点存储结构2.初始化链栈为空栈（InitStack_Link）3.输入要入栈的元素个数n4.向链栈中压入n个元素（Push_Link）5.从栈顶到栈底遍历链栈数据（StackTraverse_Link）6.销毁链栈（DestroyStack_Link）54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格六、链栈的入栈1.定义链栈的入栈函数（Push_Link）2.输入要入栈的元素个数n3.向栈中压入n个元素4.将链栈中的元素从栈顶到栈底依次输出（StackTraverse_Link）5.销毁链栈（DestroyStack_Link）例如：51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格模板如下：#include <iostream>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct StackNode{SElemType data;struct StackNode *next;}StackNode,*LinkStack;Status InitStack_Link(LinkStack &S){}void DestroyStack_Link(LinkStack &S){}bool StackEmpty_Link(LinkStack S){}//此处定义入栈函数Push_Linkvoid StackTraverse_Link(LinkStack S){}int main(){LinkStack S;int n;SElemType e;InitStack_Link(S);cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Link(S);DestroyStack_Link(S);return 0;}七、链栈的出栈1.定义求栈长函数（StackLength_Link）2.定义出栈函数（Pop_Link）3.输入要入栈的元素个数n4.向栈中压入n个元素（Push_Link）5.将栈中的元素从栈顶到栈底依次输出（StackTraverse_Link）6.输出栈长7.执行出栈操作8.将栈中的元素从栈顶到栈底依次输出9.输出出栈元素10.输出栈长11.销毁链栈（DestroyStack_Link）例如：51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格54 3 2 1 //遍历输出时最后一个元素后有一个空格54八、链栈栈顶元素的获取1.定义获取栈顶元素函数（GetTop_Link）2.输入要入栈的元素个数n3.向栈中压入n个元素（Push_Link）4.将栈中的元素从栈顶到栈底依次输出（StackTraverse_Link）5.获取栈顶元素6.输出栈顶元素7.销毁链栈（DestroyStack_Link）例如：42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8九、循环队列的建立1.定义循环队列的存储结构2.初始化循环队列为空队列（InitQueue_Sq）3.输入要入队的元素个数n4.向循环队列中输入n个元素（EnQueue_Sq）5.将循环队列中的元素从队头至队尾依次输出（StackQueue_Sq）6.销毁循环队列（DestroyQueue_Sq）例如：51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十、循环队列的入队1.定义循环队列入队函数（EnQueue_Sq）2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出（StackQueue_Sq）5.销毁循环队列（DestroyQueue_Sq）例如：56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下：#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue_Sq(SqQueue &Q) {}void DestroyQueue_Sq(SqQueue &Q) {}//此处定义入队函数EnQueue_Sqvoid QueueTraverse_Sq(SqQueue Q) {}int main(){SqQueue Q;QElemType e;InitQueue_Sq(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Sq(Q);DestroyQueue_Sq(Q);return 0;}十一、循环队列的出队1.定义求循环队列队长函数（QueueLength_Sq）2.定义循环队列的出队函数（DeQueue_Sq）3.输入要入队的元素个数n4.向循环队列中输入n个元素5.将循环队列中的元素从队头至队尾依次输出（StackQueue_Sq）6.输出队长7.执行出队操作8.将循环队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁循环队列（DestroyQueue_Sq）例如：51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十二、循环队列队头元素的获取1.定义获取循环队列队头元素函数（GetHead_Sq）2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将循环队列中的元素从队头至队尾依次输出7.销毁循环队列例如：52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十三、链队列的建立1.定义链队列的存储结构2.初始化链队列为空队列（InitQueue_Link）3.输入要入队的元素个数n4.向链队列中输入n个元素（EnQueue_Link）5.将链队列中的元素从队头至队尾依次输出（StackQueue_Link）6.销毁链队列（DestroyQueue_Link）例如：51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十四、链队列的入队1.定义链队列入队函数（EnQueue_Link）2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出（StackQueue_Link）5.销链队列（DestroyQueue_Link）例如：56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下：#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue_Link(LinkQueue &Q){}void DestroyQueue_Link(LinkQueue &Q){}//此处定义入队函数EnQueue_Linkvoid QueueTraverse_Link(LinkQueue Q){}int main(){LinkQueue Q;QElemType e;InitQueue_Link(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Link(Q);DestroyQueue_Link(Q);return 0;}十五、链队列的出队1.定义求链队列队长函数（QueueLength_Link）2.定义链队列的出队函数（DeQueue_Link）3.输入要入队的元素个数n4.向链队列中输入n个元素5.将链队列中的元素从队头至队尾依次输出（StackQueue_Link）6.输出队长7.执行出队操作8.将链队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁链队列（DestroyQueue_Link）例如：51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十六、链队列队头元素的获取1.定义获取链队列队头元素函数（GetHead_Link）2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将链队列中的元素从队头至队尾依次输出7.销毁链队列例如：52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十七、栈的应用将十进制数n，转换成八进制。

农大数据结构答案

农大数据结构答案

农大数据结构答案（1）将两个递增的有序链表合并为一个递增的有序链表。

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

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

void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){pa=La->next; pb=Lb->next;Lc=pc=La; //用La的头结点作为Lc的头结点while(pa && pb){if(pa->datadata){ pc->next=pa;pc=pa;pa=pa->next;}else if(pa->data>pb->data) {pc->next=pb; pc=pb; pb=pb->next;}else {// 相等时取La的元素，删除Lb的元素pc->next=pa;pc=pa;pa=pa->next;q=pb->next;delete pb ;pb =q;}}pc->next=pa?pa:pb; //插入剩余段delete Lb; //释放Lb的头结点}（2）将两个非递减的有序链表合并为一个非递增的有序链表。

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

表中允许有重复的数据。

void union(LinkList& La, LinkList& Lb, LinkList& Lc, ) {pa = La->next; pb = Lb->next; // 初始化Lc=pc=La; //用La的头结点作为Lc的头结点Lc->next = NULL;while ( pa || pb ) {if ( !pa ) { q = pb; pb = pb->next; }else if ( !pb ) { q = pa; pa = pa->next; }else if (pa->data <= pb->data ) { q = pa; pa = pa->next; }else { q = pb; pb = pb->next; }q->next = Lc->next; Lc->next = q; // 插入}delete Lb; //释放Lb的头结点}（3）已知两个链表A和B分别表示两个集合，其元素递增排列。

数据结构实验报告 答案

数据结构实验报告 答案

数据结构实验报告答案一、实验目的本次数据结构实验的主要目的是通过实际编程和操作，深入理解和掌握常见的数据结构，如数组、链表、栈、队列、树和图等，并能够运用这些数据结构解决实际问题，提高编程能力和算法设计能力。

二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验内容1、数组操作定义一个整数数组，实现数组元素的输入、输出和查找功能。

对数组进行排序（选择排序、冒泡排序等），并输出排序后的数组。

2、链表操作构建一个单向链表，实现链表节点的插入、删除和遍历操作。

反转链表，并输出反转后的链表。

3、栈和队列操作用数组实现栈和队列的数据结构，实现入栈、出栈、入队、出队等基本操作。

利用栈实现表达式求值（中缀表达式转后缀表达式，然后计算后缀表达式的值）。

4、树的操作构建二叉树（可以采用顺序存储或链式存储），实现二叉树的前序、中序和后序遍历。

实现二叉树的查找、插入和删除节点操作。

5、图的操作用邻接矩阵或邻接表表示图，实现图的深度优先遍历和广度优先遍历。

求解图的最短路径（Dijkstra 算法或 Floyd 算法）。

四、实验步骤及代码实现1、数组操作｀｀｀cppinclude ＜iostream>using namespace std;／／数组输入函数void inputArray(int arr, int size) ｛cout ＜＜＂请输入＂＜＜ size ＜＜＂个整数：＂＜＜ endl; for （int i ＝ 0; i ＜ size; i+＋）｛cin ＞＞ arri;｝｝／／数组输出函数void outputArray(int arr, int size) ｛cout ＜＜＂数组元素为：＂＜＜ endl;for （int i ＝ 0; i ＜ size; i+＋）｛cout ＜＜ arri ＜＜＂＂；｝cout ＜＜ endl;｝／／数组查找函数int searchArray(int arr, int size, int target) ｛for （int i ＝ 0; i ＜ size; i+＋）｛if （arri ＝＝ target) ｛return i;｝｝return －1;｝／／选择排序函数void selectionSort(int arr, int size) ｛for （int i ＝ 0; i ＜ size 1; i+＋）｛int minIndex ＝ i;for （int j ＝ i ＋ 1; j ＜ size; j+＋）｛if （arrj ＜ arrminIndex) ｛minIndex ＝ j;｝｝if （minIndex!＝ i) ｛int temp ＝ arri;arri ＝ arrminIndex;arrminIndex ＝ temp;｝｝｝／／冒泡排序函数void bubbleSort(int arr, int size) ｛for （int i ＝ 0; i ＜ size 1; i+＋）｛for （int j ＝ 0; j ＜ size i 1; j+＋）｛if （arrj ＞ arrj ＋ 1) ｛int temp ＝ arrj;arrj ＝ arrj ＋ 1;arrj ＋ 1 ＝ temp;｝｝｝｝int main(）｛int size ＝ 10;inputArray(arr, size)；outputArray(arr, size)；int target ＝ 5;int result ＝ searchArray(arr, size, target)；if （result!＝－1) ｛cout ＜＜＂找到目标元素＂＜＜ target ＜＜＂，在数组中的索引为＂＜＜ result ＜＜ endl;｝ else ｛cout ＜＜＂未找到目标元素＂＜＜ target ＜＜ endl;｝selectionSort(arr, size)；outputArray(arr, size)；bubbleSort(arr, size)；outputArray(arr, size)；return 0;｝2、链表操作｀｀｀cppinclude ＜iostream>using namespace std;／／链表节点结构体struct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；／／链表插入函数void insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；if （head ＝＝ NULL) ｛head ＝ newNode;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝／／链表删除函数void deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝if （head>data ＝＝ val) ｛ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝／／链表遍历函数void traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝cout ＜＜ endl;｝／／链表反转函数ListNode reverseList(ListNode head) ｛ListNode prev ＝ NULL;ListNode curr ＝ head;while （curr!＝ NULL) ｛ListNode nextTemp ＝ curr>next; curr>next ＝ prev;prev ＝ curr;curr ＝ nextTemp;｝return prev;｝int main(）｛ListNode head ＝ NULL;insertNode(head, 1)；insertNode(head, 2)；insertNode(head, 3)；insertNode(head, 4)；insertNode(head, 5)；traverseList(head)；deleteNode(head, 3)；traverseList(head)；ListNode reversedHead ＝ reverseList(head)；traverseList(reversedHead)；return 0;｝｀｀｀3、栈和队列操作｀｀｀cppinclude ＜iostream>using namespace std;／／用数组实现栈const int MAX_SIZE ＝ 100;class Stack ｛private:int arrMAX_SIZE;int top;public:Stack(）｛top ＝－1;｝／／入栈void push(int val) ｛if （top ＝＝ MAX_SIZE 1) ｛cout ＜＜＂栈已满，无法入栈" ＜＜ endl; return;｝arr+＋top ＝ val;｝／／出栈int pop(）｛if （top ＝＝－1) ｛cout ＜＜＂栈为空，无法出栈" ＜＜ endl; return －1;｝int val ＝ arrtop;top;return val;｝／／查看栈顶元素int peek(）｛if （top ＝＝－1) ｛cout ＜＜＂栈为空" ＜＜ endl;return －1;｝return arrtop;｝／／判断栈是否为空bool isEmpty(）｛return top ＝＝－1;｝｝；／／用数组实现队列class Queue ｛private:int arrMAX_SIZE;int front, rear;public:Queue(）｛front ＝ rear ＝－1;｝／／入队void enqueue(int val) ｛if （（rear ＋ 1) ％ MAX_SIZE ＝＝ front) ｛cout ＜＜＂队列已满，无法入队" ＜＜ endl; return;｝if （front ＝＝－1) ｛front ＝ 0;｝rear ＝（rear ＋ 1) ％ MAX_SIZE;arrrear ＝ val;｝／／出队int dequeue(）｛if （front ＝＝－1) ｛cout ＜＜＂队列为空，无法出队" ＜＜ endl; return －1;｝int val ＝ arrfront;if （front ＝＝ rear) ｛front ＝ rear ＝－1;｝ else ｛front ＝（front ＋ 1) ％ MAX_SIZE;｝return val;｝／／查看队头元素int peek(）｛if （front ＝＝－1) ｛cout ＜＜＂队列为空" ＜＜ endl;return －1;｝return arrfront;｝／／判断队列是否为空bool isEmpty(）｛return front ＝＝－1;｝｝；／／表达式求值函数int evaluateExpression(string expression) ｛Stack operandStack;Stack operatorStack;for （int i ＝ 0; i ＜ expressionlength(）； i+＋）｛char c ＝ expressioni;if （isdigit(c)）｛int operand ＝ 0;while （i ＜ expressionlength(）＆＆ isdigit(expressioni)）｛operand ＝ operand 10 ＋（expressioni+＋＇0'）；｝i;operandStackpush(operand)；｝ else if （c ＝＝＇＋＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇＇｜｜ c ＝＝＇／＇）｛while （！operatorStackisEmpty(）＆＆precedence(operatorStackpeek(））＞＝ precedence(c)）｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝operatorStackpush(c)；｝ else if （c ＝＝＇（＇）｛operatorStackpush(c)；｝ else if （c ＝＝＇）＇）｛while （operatorStackpeek(）！＝＇（＇）｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝operatorStackpop(）；｝｝while （！operatorStackisEmpty(））｛int operand2 ＝ operandStackpop(）；int operand1 ＝ operandStackpop(）；char op ＝ operatorStackpop(）；int result ＝ performOperation(operand1, operand2, op)；operandStackpush(result)；｝return operandStackpop(）；｝／／运算符优先级函数int precedence(char op) ｛if （op ＝＝＇＋＇｜｜ op ＝＝＇＇）｛return 1;｝ else if （op ＝＝＇＇｜｜ op ＝＝＇／＇）｛return 2;｝return 0;｝／／运算函数int performOperation(int operand1, int operand2, char op) ｛switch （op) ｛case ＇＋＇：return operand1 ＋ operand2;case ＇＇：return operand1 operand2;case ＇＇：return operand1 operand2;case ＇／＇：if （operand2!＝ 0) ｛return operand1 ／ operand2;｝ else ｛cout ＜＜＂除数不能为 0" ＜＜ endl;return －1;｝｝return －1;｝int main(）｛Stack stack;stackpush(1)；stackpush(2)；stackpush(3)；cout ＜＜＂栈顶元素：＂＜＜ stackpeek(）＜＜ endl;cout ＜＜＂出栈元素：＂＜＜ stackpop(）＜＜ endl;cout ＜＜＂栈是否为空：＂＜＜（stackisEmpty(）？＂是" ：＂否"）＜＜ endl;Queue queue;queueenqueue(1)；queueenqueue(2)；queueenqueue(3)；cout ＜＜＂队头元素：＂＜＜ queuepeek(）＜＜ endl;cout ＜＜＂出队元素：＂＜＜ queuedequeue(）＜＜ endl;cout ＜＜＂队列是否为空：＂＜＜（queueisEmpty(）？＂是" ：＂否"）＜＜ endl;string expression ＝＂2+34"；int result ＝ evaluateExpression(expression)；cout ＜＜ expression ＜＜＂＝＂＜＜ result ＜＜ endl; return 0;｝｀｀｀4、树的操作｀｀｀cppinclude ＜iostream>using namespace std;／／二叉树节点结构体struct TreeNode ｛int val;TreeNode left;TreeNode right;TreeNode(int x) ： val(x)， left(NULL)， right(NULL) ｛｝｝；／／前序遍历函数void preOrderTraversal(TreeNode root) ｛return;｝cout ＜＜ root>val ＜＜＂＂；preOrderTraversal(root>left)；preOrderTraversal(root>right)；｝／／中序遍历函数void inOrderTraversal(TreeNode root) ｛if （root ＝＝ NULL) ｛return;｝inOrderTraversal(root>left)；cout ＜＜ root>val ＜＜＂＂；inOrderTraversal(root>right)；｝／／后序遍历函数void postOrderTraversal(TreeNode root) ｛return;｝postOrderTraversal(root>left)；postOrderTraversal(root>right)；cout ＜＜ root>val ＜＜＂＂；｝／／查找函数TreeNode searchBST(TreeNode root, int val) ｛if （root ＝＝ NULL ｜｜ root>val ＝＝ val) ｛return root;｝if （val ＜ root>val) ｛return searchBST(root>left, val)；｝ else ｛return searchBST(root>right, val)；｝｝／／插入函数TreeNode insertBST(TreeNode root, int val) ｛if （root ＝＝ NULL) ｛return new TreeNode(val)；｝if （val ＜ root>val) ｛root>left ＝ insertBST(root>left, val)；｝ else if （val ＞ root>val) ｛root>right ＝ insertBST(root>right, val)；｝return root;｝／／删除函数TreeNode deleteNodeBST(TreeNode root, int key) ｛if （root ＝＝ NULL) ｛return root;｝if （key ＜ root>val) ｛root>left ＝ deleteNodeBST(root>left, key)；｝ else if （key ＞ root>val) ｛root>right ＝ deleteNodeBST(root>right, key)；｝ else ｛if （root>left ＝＝ NULL) ｛TreeNode temp ＝ root>right;delete root;return temp;｝ else if （root>right ＝＝ NULL) ｛TreeNode temp ＝ root>left;delete root;return temp;｝TreeNode minNode ＝ root>right;while （minNode>left!＝ NULL) ｛minNode ＝ minNode>left;｝root>val ＝ minNode>val;root>right ＝ deleteNodeBST(root>right, minNode>val)；｝return root;｝int main(）｛TreeNode root ＝ new TreeNode(4)；root>left ＝ new TreeNode(2)；root>right ＝ new TreeNode(6)；root>left>left ＝ new TreeNode(1)；root>left>right ＝ new TreeNode(3)；root>right>left ＝ new TreeNode(5)；root>right>right ＝ new TreeNode(7)；cout ＜＜＂前序遍历：＂＜＜ endl; preOrderTraversal(root)；cout ＜＜ endl;cout ＜＜＂中序遍历：＂＜＜ endl; inOrderTraversal(root)；cout ＜＜ endl;cout ＜＜＂后序遍历：＂＜＜ endl; postOrderTraversal(root)；cout ＜＜ endl;int target ＝ 3;TreeNode foundNode ＝ searchBST(root, target)；if （foundNode!＝ NULL) ｛cout ＜＜＂找到目标节点＂＜＜ target ＜＜ endl;｝ else ｛cout ＜＜＂未找到目标节点＂＜＜ target ＜＜ endl;｝root ＝ insertBST(root, 8)；cout ＜＜＂插入节点 8 后的中序遍历：＂＜＜ endl; inOrderTraversal(root)；cout ＜＜ endl;root ＝ deleteNodeBST(root, 2)；cout ＜＜＂删除节点 2 后的中序遍历：。

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

数据结构完整题目及答案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 门课的成绩信息。

华南农业大学数据结构java版实验二

华南农业大学数据结构java版实验二

华南农业大学信息（软件）学院《数据结构（JAVA ）》综合性、设计性实验成绩单开设时间：2017学年第二学期实验目的:理解线性表的逻辑结构、两种存储结构和数据操作，熟练运用 表的基本操作，分析各种操作算法特点和时间复杂度。

掌握单链表的遍历、插入和删除等操作算法，实现多项式相加。

实验内容:1、设计一个有序顺序表（元素已排序，递增或递减） 位置由其值决定。

实现：（1） 升序排序顺序表类名为：SortedSeqList ，存成SortedSeqList.java 文件;（2） 另外编写 SortedSeqList_ex.java} publicboolean I isEmpty() { returnlength == 0;实验报告线性表(1)JAVA 语言实现线性，实现插入、删除等操作，元素插入文件来演示调用排序顺序表:class SortedSeqList {private int MAX_SIZE private int [] ary = private intlen gth='publicSortedSeqList(if (array ==nullthis . length =} else {ary = array ;len gth = array}}public void clear() {int [MAX_SIZE];array ) {[]array . length == 0) {len gth ;=10; new 0; int || :0;len gth = 0;精选文库} public ifvoid delete( int index ) throws Exception {len gth == 0) { throw new Exce pti on("No elme nt to delete"）；} int fornewAry [] = new int[ary . length- 1];(int ifary = len gth public if } int intfor i = 0, j = 0; (i == index ) { con ti nue ;else {newAry [ j ++]=newAry ;ary insert( int value ) (length == MAX_SIZE) { throw new Exce pti on(int [] i (; if while< ary . length ; i ++) {[i]；throws Exce pti on { "List is full, can't in sert more");newAry = new int =0, j = 0; i < ary . length ; [length + 1];i ++, j++) { (ary [ i ] >= value ) { newAry [ j ] = value ; break ; else {newAry [ j ] = ary [ i ];(i < ary . length ) { newAry [++ j ]= i ++;ary [ i ];ary = len gth returnnewAry ; ++■ value ;} p ublic void System.dis playO { out .println( "\nList now is:" ); for (int i = 0; i< ary . length ; iSystem. out .print(ary [ i ] +"\t"}++) { );}(2)SortedSeqList_ex.java文件来演示调用排序顺序表p ublic class SortedSeqList_ex {p ublic static void main( Stri ng[] args) throws Exce pti on {in t[] ary = {1,2, 3, 5, 7};SortedSeqList list = new SortedSeqList(ary); list.dis play(); list.i nsert(4); list.dis play(); list.delete(2); list.dis play();}}(3 )实验结果v Wrnilnjhifl ■沖[却卩屮dAf 屮 1)*lliV'J< 卜屮*必程衲上人91 i4 <*」U£l ISi 1 2 ILis-t g* ii■-1 J(Kl 1至，wuBbit刼血詬申 1$' I} p ublicNode(){this ( null}}package Q2;2、在SinglyLinkedList 类中增加下列成员方法。

数据结构实验报告10图的操作答案

数据结构实验报告10图的操作答案
printf("请输出顶点信息: ");
for(i=0;i<G->n;i++){//建立顶点表
while((G->adjlist[i].vertex=getchar())=='\n');//读入顶点信息
G->adjlist[i].firstedge=NULL;//边表置为空表
}
for(k=0;k<G->e;k++){//建立边表
VertexType vertex;//顶点域
EdgeNode *firstedge;//边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum];
//AdjList是邻接表类型
typedef struct {
AdjList adjlist;//邻接表
实 验 报 告
院（系）:信息科学与技术学院课程名称:数据结构日期:
班级
学号
实验室
专业
姓名
计算机号
实验名称
图的存储与基本操作
成绩评定
所用软件
V C或TC
教师签名
实
验
目
的
（1）掌握图的存储结构；
（2）实现图的邻接矩阵存储。
（3）掌握图的遍历方法。
实
验
准
备
1、复习书上有关内容。
2、阅读实验内容1。
3、编出实验内容2.3的源程序。
}
}
//打印邻接表:
void PrintALGraph(ALGraph *G)
{
int i;
EdgeNode *p;
for(i=0;i<G->n;i++)

数据结构实验指导书及其答案pdf

数据结构实验指导书及其答案pdf

引言概述正文内容
1.实验环境配置
1.1硬件要求
计算机硬件配置要求
操作系统要求
附加硬件设备要求（如虚拟机等）
1.2软件要求
编程语言要求（如C/C++、Java等）开发环境配置（如IDE、编译器等）1.3实验库和工具
实验需要使用的库文件和工具
如何获取和配置实验库和工具
2.实验内容介绍
2.1实验目标和背景
数据结构实验的作用和意义
实验背景和相关应用领域介绍
2.2实验概述
实验内容的大致流程和步骤
实验中可能遇到的问题和挑战
2.3实验要求
对学生实验流程和实验结果的要求
实验过程中需要注意的事项和技巧
3.实验步骤
3.1实验准备
配置实验环境
获取实验所需数据和文件
3.2实验具体步骤
根据实验要求将数据结构知识应用到具体问题中根据实验要求实现相应的算法和数据结构
3.3实验示例代码
提供示例代码以供学生参考和学习
解析示例代码中的关键步骤和实现细节
4.实验答案
4.1实验题目
实验题目及相关说明
确定实验的具体要求和目标
4.2实验答案解析
对实验答案的具体实现进行解析
对实验中可能遇到的问题和错误进行分析和解决4.3实验答案示例
提供实验答案的示例代码
解析实验答案中的关键实现步骤和说明
5.实验总结
5.1实验成果评估
对学生实验成果进行评估
分析实验结果的优点和不足
5.2实验心得
学生对本次实验的收获和感想
学生对未来实验的建议和展望
总结。

2022数据结构答案

2022数据结构答案

1. (判断题) 在有n个叶子结点的哈夫曼树中,其结点总数2n+1。

( )(本题2.0分)A. 正确B. 错误学生答案: B标准答案: B解析：得分: 22. (判断题) 链表由头指针唯一确定。

( )(本题2.0分)A. 正确B. 错误学生答案: A标准答案: A解析：得分: 23. (判断题) 完全二叉树的叶子结点只能出现在最后一层上。

( )(本题2.0分)A. 正确B. 错误学生答案: B解析：得分: 24. (判断题) 由树转化来的二叉树一定没有右子树。

( )(本题2.0分)A. 正确B. 错误学生答案: A标准答案: A解析：得分: 25. (判断题) 折半查找要求数据必须有序,且采用顺序存储结构。

( )(本题2.0分)A. 正确B. 错误学生答案: A标准答案: A解析：得分: 26. (判断题) 有回路的图不能进行拓朴排序。

( )(本题2.0分)B. 错误学生答案: A标准答案: A解析：得分: 27. (判断题) 在顺序存储的线性表中,逻辑上相邻的两个数据元素在物理位置上并不一定紧邻。

( )(本题2.0分)A. 正确B. 错误学生答案: B标准答案: B解析：得分: 28. (判断题) 链式存储的线性表可以随机存取。

( )(本题2.0分)A. 正确B. 错误学生答案: B标准答案: B解析：9. (判断题) 散列表的查找效率主要取决于建表时所选取的散列函数和处理冲突的方法。

( )(本题2.0分)A. 正确B. 错误学生答案: A标准答案: A解析：得分: 210. (判断题) 对于同一组记录,生成的二叉排序树的形态与记录的输入次序无关。

( )(本题2.0分)A. 正确B. 错误学生答案: B标准答案: B解析：得分: 211. (单选题) 设有一个二维数组A[10][15],数组按行存放,假设A[0][0]存放位置在644,每个元素占一个空间,则A[4][5]在( )位置。

(本题2.0分)B. 626C. 709D. 724学生答案: C标准答案: C解析：得分: 212. (单选题) 顺序查找方法适用于存储结构为( )的线性表。

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

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

华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈，并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。

请将下#include&lt;malloc.h&gt;#include&lt;stdio.h&gt;#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 &amp;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 &amp;S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base&gt;=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 &amp;S,SElemType &amp;e){// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &amp;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(&quot;The Stack is Empty!&quot;); //请填空else{printf(&quot;The Stack is: &quot;);p--;while(p&gt;=S.base) //请填空{printf(&quot;%d &quot;, *p);p--; //请填空}}printf(&quot;\n&quot;);return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功，请填空{printf(&quot;A Stack Has Created.\n&quot;);}while(1){printf(&quot;1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n&quot;);scanf(&quot;%d&quot;,&amp;a);switch(a){case 1: scanf(&quot;%d&quot;, &amp;x);if(!Push(S,x)) printf(&quot;Push Error!\n&quot;); // 判断Push是否合法，请填空else printf(&quot;The Element %d is Successfully Pushed!\n&quot;, x); break;case 2: if(!Pop(S,e)) printf(&quot;Pop Error!\n&quot;); // 判断Pop是否合法，请填空else printf(&quot;The Element %d is Successfully Poped!\n&quot;, e); break;case 3: if(!GetTop(S,e))printf(&quot;Get Top Error!\n&quot;); // 判断Get Top 是否合法，请填空else printf(&quot;The Top Element is %d!\n&quot;, e);break;case 4: printf(&quot;The Length of the Stack is %d!\n&quot;,StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列，并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。

《数据结构》实验报告二及其答案

《数据结构》实验报告二及其答案

《数据结构》实验报告二学校：班级：09软工A1学号：09XXXXX 姓名：XXX日期：2010 .04.08 程序名：L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。

设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。

具体实现要求：1.从键盘输入20个整数，产生带表头的单链表，并输入结点值。

2.从键盘输入1个整数，在单链表中查找该结点。

若找到，则显示“找到了”；否则，则显示“找不到”。

3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。

4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。

5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。

6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。

7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。

8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。

二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：#include <iostream.h>//单链表的定义：typedef int DataType; //DataType可以是任何相应的数据类型如int, float或char typedef struct node //结点类型定义{ DataType data; //结点的数据域struct node *next; //结点的指针域}ListNode,*LinkList;//typedef ListNode *LinkList;void main(){int i;DataType key,x;LinkList head;//ListNode *p;LinkList p;LinkList CreateList(void);void PrintList(LinkList head);LinkList LocateNode(LinkList head,DataType key);LinkList GetNode(LinkList head,int i);void InsertList(LinkList head,DataType x,int i);void DeleteList(LinkList head,int i);void DeleteManyList(LinkList head);void DeleteEvenList(LinkList head);void ChangeCircList(LinkList head);void PrintCircList(LinkList head);head=CreateList(); //建立单链表PrintList(head); //打印单链表cout<<"输入要查找的值:";cin>>key;p=LocateNode(head,key); //单链表查找cout<<"输入要查找的位置:";cin>>i;p=GetNode(head, i);cout<<"请输入欲插入元素的位置:";cin>>i;cout<<"请输入欲插入的元素(整数):";cin>>x;InsertList(head,x,i); //单链表插入PrintList(head); //打印单链表cout<<"请输入欲删除结点的位置:";cin>>i;DeleteList(head,i); //单链表删除PrintList(head); //打印单链表DeleteManyList(head); //删除重复值PrintList(head); //打印单链表DeleteEvenList(head); //删除偶数值PrintList(head); //打印单链表ChangeCircList(head); //修改为循环单链表PrintCircList(head); //打印循环单链表/*void DivideList(LinkList head,LinkList *A,LinkList *B);//分割成两个单链表DivideList(head, &A, &B);PrintList(A);PrintList(B);*/}//单链表的建立：LinkList CreateList(void){LinkList head,p,q;head=new ListNode;head->next=NULL;q=head;cout<<"输入20个整数(以空格分隔):";for(int i=0;i<20;i++){p=new ListNode;cin>>p->data;q->next=p;q=q->next;}q->next=NULL;return head;//在此插入必要的语句}//单链表的打印：void PrintList(LinkList head){LinkList L=head;cout<<"单链表打印:";while(L->next!=NULL){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}//单链表的查找1：LinkList LocateNode(LinkList head,DataType key) {LinkList L=head;while(L->next!=NULL){{cout<<"找到了!\n";return L;}L=L->next;}cout<<"没找到!\n";return L;//在此插入必要的语句}//*单链表的查找2：LinkList GetNode(LinkList head,int i){LinkList L=head;for(int j=1;j<=i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}cout<<L->data;cout<<"找到了!\n";return L;}//单链表的插入：void InsertList(LinkList head,DataType x,int i){LinkList L=head,p;for(int j=1;j<i;j++){//if(L->next->next==NULL){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表尾部!>\n";break;}L=L->next;}if(i<=0){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表的头结的后面!>\n";}//L=L->next;p=new ListNode;p->data=x;p->next=L->next;L->next=p;//在此插入必要的语句}//单链表的删除：void DeleteList(LinkList head,int i){LinkList L=head;for(int j=1;j<i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}L->next=L->next->next;cout<<"删除成功!\n";//在此插入必要的语句}//删除单链表中重复值：void DeleteManyList(LinkList head){LinkList L=head,p;cout<<"删除链表中重复的元素\n";while(L->next!=NULL){p=L->next;while(p->next!=NULL){if(L->next->data==p->next->data)L->next=L->next->next;p=p->next;}L=L->next;}//在此插入必要的语句}//删除单链表中偶数值：void DeleteEvenList(LinkList head){LinkList L=head;cout<<"删除链表中的偶数值\n";do{if(L->next->data%2==0){if(L->next->next!=NULL)L->next=L->next->next;else{L->next=NULL;break;}}L=L->next;}while(L->next!=NULL);//在此插入必要的语句}//修改为循环单链表：void ChangeCircList(LinkList head){LinkList L=head;cout<<"修改为循环单链表\n";while(L->next!=NULL){L=L->next;}L->next=head;//在此插入必要的语句}//循环单链表的打印：void PrintCircList(LinkList head){LinkList L=head;cout<<"循环单链表打印:";while(L->next!=head){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}/*//分割成两个单链表void DivideList(LinkList head,LinkList *A,LinkList *B); {//在此插入必要的语句}*/四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：当需要插入和删除的数值超过20时，如果不写：if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}那么就会不产生效果.六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：。

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

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

目录实验一线性表 (1)(一) 实验目的 (1)(二) 实验内容 (1)(三) 实验报告 (22)实验二堆栈 (23)(一) 实验目的 (23)(二) 实验内容 (23)(三) 实验报告 (41)实验三队列 (43)(一) 实验目的 (43)(二) 实验内容 (43)(三) 实验报告 (50)实验四模式匹配 (51)(一) 实验目的 (51)(二) 实验内容 (51)(三) 实验报告 (57)实验五二叉树 (58)(一) 实验目的 (58)(二) 实验内容 (58)(三) 实验报告 (85)实验六查找 (86)(一) 实验目的 (86)(二) 实验内容 (86)(三) 实验报告 (95)实验七内部排序 (96)(一) 实验目的 (96)(二) 实验内容 (96)(三) 实验报告 (113)实验八图和图的遍历 (114)(一) 实验目的 (114)(二) 实验内容 (114)(三) 实验报告 (131)数据结构课程设计（2007级用，仅做参考） (132)(一) 数据结构课程设计安排 (132)(二) 图算法实验题目 (132)(三) 团队题目（各种排序算法效率分析） (132)《数据结构》模拟试卷一 (136)《数据结构》模拟试卷二 (139)附录1：实验报告及习题 (142)实验名称：线性表（一） (142)实验名称：堆栈（二） (144)实验名称：队列（三） (146)实验名称：模式匹配（四） (149)实验名称：二叉树（五） (151)实验名称：查找（六） (153)实验名称：内部排序（七） (155)实验名称：图和图的遍历（八） (159)设计性、综合性实验 (161)附录2 数据结构课程设计完成情况登记表 (162)附录3 图的应用 (163)实验一线性表(一) 实验目的（1）掌握线性表的顺序存储（2）掌握线性表的链式存储（3）掌握基本算法（建表、插入、删除）的实现(二) 实验内容1. 线性表的顺序存储：掌握线性表的顺序存储结构及其基本操作、合并、逆置等算法设顺序表的存储结构定义如下：（同学们可扩展考虑其他形式的存储结构定义）#define LIST_INIT_SIZE 100 // 线性表存储空间的初始分配量#define LISTINCREMENT 10 // 线性表存储空间的分配增量typedef struct{int *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量（以sizeof(int)为单位）}SqList;[题目1：编写算法，创建初始化容量为LIST_INIT_SIZE的顺序表T，并实现插入、删除、遍历操作。

数据结构实验答案

数据结构实验答案

实验一：以单链表表示集合，设计算法建立先后输入的两个集合的差。

说明：已知两个集合A和B，集合A-B中包含所有属于集合A而不属于集合B 的元素。

步骤：1.首先建立A和B的单链表2.然后对集合B中的每个元素x，在A中查找，若存在和x相同的元素，则从该链表中删除。

3.打印A-B，进行验证。

实验二：建立一个二叉树，并进行先序和中序遍历。

（递归和非递归算法）步骤1.补充元素0建立一个满二叉树，存储到一维数组2.利用递归算法建立二叉树，注意零的元素处置3．进行递归、非递归的中序和先序遍历。

打印结果。

实验三：先从键盘输入26个字母生成无序数组，对数组排序后，再从键盘输入一个字符进行折半查找。

实验四：为一个图（maxnode＝20）建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。

实验一答案：#include<stdio.h>typedef struct linknode{int data;struct linknode *next;} node;node *creatlist(){node *head,*r,*s;int x;head=(node*)malloc(sizeof(node));r=head;printf("input int and end with \n");scanf("%d",&x);while(x!=0){s=(node*)malloc(sizeof(node));s->data=x;r->next=s;s->next=NULL;r=s;scanf("%d",&x);}r->next=NULL;s=head;head=head->next;free(s);return(head);}void subs(){node *p,*p1,*p2,*q,*heada,*headb;heada=creatlist();headb=creatlist();p=heada;p1=p;while(p!=NULL){q=headb;while(q->data!=p->data && q!=NULL) q=q->next; if(q!=NULL){if(p==heada){heada=heada->next;p1=heada;}else if(p->next==NULL) p1->next=NULL;else p1->next=p->next;p2=p->next;p->next=NULL;free(p);p=p2;}else{p1=p;p=p->next;}}p=heada;if(p==NULL)printf("kong\n");elseprintf(" A - B \n");while(p!=NULL){printf("%d\n",p->data);p=p->next;}}main(){subs();}实验二答案：//程序目的建立二叉树，同时对他进行先序排列。

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

8576 顺序线性表的基本操作时间限制:1000MS 内存限制:1000K提交次数:9027 通过次数:2456题型: 编程题语言: 无限制Description编写算法，创建初始化容量为LIST_INIT_SIZE的顺序表T，并实现插入、删除、遍历操作。

本题目给出部分代码，请补全内容。

#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem;int length;int listsize;}SqList;int InitList_Sq(SqList &L){n");}while(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPleasechoose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d%d",&i,&x);if(_________________________) printf("Insert Error!\n"); 1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The Element 2 is Successfully Inserted!1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The Element 3 is Successfully Inserted!1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The Element 3 is Successfully Deleted!1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The List is: 21:Insert element2:Delete element3:Load all elements0:ExitPlease choose:作者yqm解法一：（正规解法）#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType inttypedef struct{int *elem;int length;int listsize;}SqList;int InitList_Sq(SqList &L) {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"); 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(i<1||i>(int)()+1) printf("Insert Error!\n"); 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(i<1||i>k) printf("Insert Error!\n");., ai,...an-1)，其逆顺序表定义为A'=( an-1,..., ai,...,a1, a0)。

设计一个算法，将顺序表逆置，要求顺序表仍占用原顺序表的空间。

本题不提供代码，请同学们独立完成，所需子函数参考前面完成的内容。

输入格式第一行：输入顺序表的元素个数第二行：输入顺序表的各元素，用空格分开输出格式第一行：逆置前的顺序表元素列表第二行：逆置后的顺序表元素列表输入样例101 2 3 4 5 6 7 8 9 10输出样例The List is:1 2 3 4 5 6 7 8 9 10The turned List is:10 9 8 7 6 5 4 3 2 1作者yqm解法一：（正规解法）#include<>#include<>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem;int length;int listsize;}SqList;int InitList_Sq(SqList &L,int n){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(___________________________) printf("Insert Error!\n"); The LinkList is:3 6 91:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The LinkList is:3 6 91:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The Element 12 is Successfully Inserted! 1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The Element 3 is Successfully Deleted! 1:Insert element2:Delete element3:Load all elements0:ExitPlease choose:The LinkList is:6 9 121:Insert element2:Delete element3:Load all elements0:ExitPlease choose:作者yqm解法一：（正规解法）#include<>#include<>#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){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"); n");for(i=0;i<n;i++){scanf("%d",&x);(x);}load(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(i<1||i>(int)()+1) printf("Insert Error!\n"); n");if(k==1) printf("The List is empty!");else{printf("The LinkList is:");for(int j=1; j<k; j++) printf("%d ",T[j]);}printf("\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(i<1||i>k) printf("Insert Error!\n");., ai,...an-1)，其逆线性表定义为A'=( an-1,..., ai,...,a1, a0)，设计一个算法，将线性表逆置，要求线性表仍占用原线性表的空间。

相关文档
最新文档