华南农业大学数据结构实验答案(包含STL版)

合集下载

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

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

华农数据结构上机实验答案数据结构上机答案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):查找链表中指定元素的节点通过实现上述方法,我们可以对链表进行各种操作。

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

(完整版)数据结构课后习题答案(可编辑修改word版)

(完整版)数据结构课后习题答案(可编辑修改word版)

第1 章绪论1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。

答案:数据:是客观事物的符号表示,指所有能输入到计算机中并被计算机程序处理的符号的总称。

如数学计算中用到的整数和实数,文本编辑所用到的字符串,多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。

数据元素:是数据的基本单位,在计算机中通常作为一个整体进行考虑和处理。

在有些情况下,数据元素也称为元素、结点、记录等。

数据元素用于完整地描述一个对象,如一个学生记录,树中棋盘的一个格局(状态)、图中的一个顶点等。

数据项:是组成数据元素的、有独立含义的、不可分割的最小单位。

例如,学生基本信息表中的学号、姓名、性别等都是数据项。

数据对象:是性质相同的数据元素的集合,是数据的一个子集。

例如:整数数据对象是集合N={0,±1,±2,… },字母字符数据对象是集合C={‘A’,‘B’,… ,‘Z’,‘a’,‘b’,…,‘z’},学生基本信息表也可是一个数据对象。

数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。

换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。

逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。

因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。

存储结构:数据对象在计算机中的存储表示,也称为物理结构。

抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。

具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。

2.试举一个数据结构的例子,叙述其逻辑结构和存储结构两方面的含义和相互关系。

答案:例如有一张学生基本信息表,包括学生的学号、姓名、性别、籍贯、专业等。

每个学生基本信息记录对应一个数据元素,学生记录按顺序号排列,形成了学生基本信息记录的线性序列。

数据结构实验题参考答案

数据结构实验题参考答案

【实验题】1.狐狸逮兔子围绕着山顶有10个圆形排列的洞,狐狸要吃兔子,兔子说:“可以,但必须找到我,我就藏身于这十个洞中,你先到1号洞找,第二次隔1个洞(即3号洞)找,第三次隔2个洞(即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。

华南农业大学期末考试试卷及参考答案

华南农业大学期末考试试卷及参考答案

华南农业大学期末考试试卷及参考答案2011学年第一学期考试科目:数据结构考试类型:(闭卷) 考试时间: 120 分钟班级学号姓名考试须知:1.答案必须写在“答题卡”上,写在试卷上不得分。

2.考试结束时,只回收答题卡,不回收试卷。

3. 必须在答题卡上正确填写班级、学号、姓名等内容,否则没有考试成绩一、选择题(每小题2分,共20分)1、有n个顶点的有向图最多有( )条边。

BA.n B.n(n—1) C n(n+1) D. n22、任何一个无向连通图(B )最小生成树。

A.只有一棵B.有一棵或多棵C.一定有多棵D.可能不存在3、如果从无向图的任一顶点出发进行一次深度优先遍历即可访问所有顶点,则该图一定是( B)。

A.完全图B. 连通图C. 有回路D. 一棵树4、有一个有序表位{1,3,9,12,32,41,45,62,75,77,82,95,99},当采用二分查找法查找关键字为82的元素时,(C )次比较后查找成功。

A.1 B.2 C.4 D.85、对一组数据(84,47,25,15,21)排序,数据的排列次序在排序的过程中的变化为:(1)84 47 25 15 21 (2)15 47 25 84 21 (3)15 21 25 84 47 (4) 15 21 25 47 84则采用的排序是( )。

AA. 选择排序B. 冒泡排序C. 快速排序D. 插入排序6、数据序列(8,9,10,4,5,6,20,1,2)只能是下列排序算法中的( )的两趟排序后的结果。

CA.选择排序B.冒泡排序C.插入排序D.堆排序7、在平衡二叉树中插入一个结点后造成了不平衡,设最低的不平衡结点为A,并已知插入结点后A 的左孩子的平衡因子为0,右孩子的平衡因子为1,则应作( ) 型调整以使其平衡。

CA.LL B.LR C.RL D.RR8、快速排序算法的时间复杂性为O(nlog2n),但在( )情况下,该算法效率近似为O (n2)。

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 后的中序遍历:。

(完整版)数据结构实验答案及解析

(完整版)数据结构实验答案及解析

《数据结构》实验指导2013 / 2014 学年第 2学期姓名:______________学号:_________班级:______________指导教师:______________潍坊学院计算机工程学院2014预备实验 C语言的函数数组指针结构体知识一、实验目的1、复习C语言中函数、数组、指针和结构体的概念。

2、熟悉利用C语言进行程序设计的一般方法。

二、实验内容和要求1、调试程序:输出100以内所有的素数(用函数实现)。

#include<stdio.h>/*判断一个数是否为素数*/int isprime(int n){for(int m=2;m*m<=n;m++){if(n%m= =0) return 0;return 1;}/*输出100以内所有素数*/int main(){int i;for(i=2;i<100;i++)if(isprime(i)= =1) printf(“%4d”,i);return 0;}运行结果:2、调试程序:对一维数组中的元素进行逆序排列。

#include<stdio.h>#define N 10int main(){int a[N]={0,1,2,3,4,5,6,7,8,9},i,temp;printf(“the original Array is:\n ”);for(i=0;i<N;i++)printf(“%4d”,a[i]);for(i=0;i<N/2;i++){ /*交换数组元素使之逆序*/temp=a[i];a[i]=a[N-i-1];a[N-i-1]=temp;}printf(“\nthe changed Array is:\n”);for(i=0;i<N;i++)printf(“%4d”,a[i]);return 0;}运行结果:3、调试程序:在二维数组中,若某一位置上的元素在该行中最大,而在该列中最小,则该元素即为该二维数组的一个鞍点。

(最新版)数据结构实验报告答案

(最新版)数据结构实验报告答案

《数据结构与算法分析》课程设计内容体系主要内容《数据结构课程设计》课程,可使学生深化理解书本知识,致力于用学过的理论知识和上机取得的实践经验,解决具体、复杂的实际问题,培养软件工作者所需的动手能力、独立解决问题的能力。

该课程设计侧重软件设计的综合训练,包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧、多人合作,以至一整套软件工作规范的训练和科学作风的培养。

一、课程设计要求学生必须仔细阅读《数据结构与算法分析》课程设计方案,认真主动完成课程设计的要求。

有问题及时主动通过各种方式与教师联系沟通。

学生要发挥自主学习的能力,充分利用时间,安排好课程设计的时间计划,并在课程设计过程中不断检测自己的计划完成情况,及时的向教师汇报。

课程设计按照教学要求需要两周时间完成,两周中每天(按每周5天)至少要上3-4小时的机来调试C语言设计的程序,总共至少要上机调试程序30小时。

二、数据结构课程设计的具体内容本次课程设计完成如下模块(共9个模块,学生可以在其中至少挑选6个功能块完成,但有**号的模块是必须要选择的)(1)运动会分数统计**任务:参加运动会有n个学校,学校编号为1……n。

比赛分成m个男子项目,和w个女子项目。

项目编号为男子1……m,女子m+1……m+w。

不同的项目取前五名或前三名积分;取前五名的积分分别为:7、5、3、2、1,前三名的积分分别为:5、3、2;哪些取前五名或前三名由学生自己设定。

(m<=20,n<=20)功能要求:可以输入各个项目的前三名或前五名的成绩;●能统计各学校总分;●可以按学校编号、学校总分、男女团体总分排序输出;●可以按学校编号查询学校某个项目的情况;可以按项目编号查询取得前三或前五名的学校。

规定:输入数据形式和范围:20以内的整数(如果做得更好可以输入学校的名称,运动项目的名称)输出形式:有中文提示,各学校分数为整形界面要求:有合理的提示,每个功能可以设立菜单,根据提示,可以完成相关的功能要求。

数据结构与STL答案

数据结构与STL答案

数据结构与STL答案1.引言2.数组- 定义:数组是一种线性数据结构,用于存储相同类型的连续数据。

- 插入、删除和访问元素的操作。

- 数组的特点和应用场景。

3.链表- 定义:链表是一种动态数据结构,用于存储非连续的数据。

- 单链表和双向链表的实现。

- 插入、删除和访问节点的操作。

- 链表的特点和应用场景。

4.栈- 定义:栈是一种先进后出(LIFO)的数据结构。

- 基本操作:压栈和弹栈。

- 栈的应用场景。

5.队列- 定义:队列是一种先进先出(FIFO)的数据结构。

- 基本操作:入队和出队。

- 队列的应用场景。

6.树- 定义:树是一种非线性数据结构,由节点和边组成的层次关系。

- 二叉树、二叉搜索树和平衡二叉树的概念和实现。

- 通过递归和迭代方式遍历树。

- 树的应用场景。

7.图- 定义:图是一种非线性数据结构,由节点和边组成的关系网络。

- 图的表示方法:邻接矩阵和邻接表。

- 图的遍历算法:深度优先搜索和广度优先搜索。

- 图的应用场景。

8.STL简介- STL的定义和作用。

- STL的三个核心组件:容器、算法和迭代器。

9.STL容器- 各种容器的特点和用法:数组、链表、栈、队列、集合、映射等。

10.STL算法- 常用算法的介绍和使用示例:排序、查找、插入等。

11.STL迭代器- 迭代器的定义和作用。

- 迭代器的种类和使用方式。

附件:本文档附带以下附件供参考:- 示例代码- 图片和图表- 表格和算法示意图- 其他相关参考资料法律名词及注释:1.数据结构:指数据的组织、管理以及存储方式的一种策略或组织形式。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

华南农业大学数据结构实验答案(包含STL版)

华南农业大学数据结构实验答案(包含STL版)

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

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

#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;int length;int listsize;}SqList;int InitList_Sq(SqList &L){// 算法2.3,构造一个空的线性表L,该线性表预定义大小为LIST_INIT_SIZE// 请补全代码}int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(_________________________) printf("The List is empty!"); // 请填空else{printf("The List is: ");for(_________________________) printf("%d ",_________________________); // 请填空}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){// 算法2.4,在顺序线性表L中第i个位置之前插入新的元素e// i的合法值为1≤i≤L.length +1// 请补全代码}int ListDelete_Sq(SqList &L,int i, int &e){// 算法2.5,在顺序线性表L中删除第i个位置的元素,并用e返回其值// i的合法值为1≤i≤L.length// 请补全代码}int main(){SqList T;int a, i;ElemType e, x;if(_________________________) // 判断顺序表是否创建成功{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(_________________________) printf("Insert Error!\n"); // 判断i 值是否合法,请填空else printf("The Element %d is Successfully Inserted!\n", x);break;case 2: scanf("%d",&i);if(_________________________) printf("Delete Error!\n"); // 判断i 值是否合法,请填空else printf("The Element %d is Successfully Deleted!\n", e);break;case 3: Load_Sq(T);break;case 0: return 1;}}}输入格式测试样例格式说明:根据菜单操作:1、输入1,表示要实现插入操作,紧跟着要输入插入的位置和元素,用空格分开2、输入2,表示要实现删除操作,紧跟着要输入删除的位置3、输入3,表示要输出顺序表的所有元素4、输入0,表示程序结束输入样例11 211 3213输出样例A Sequence List Has Created.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<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;int length;int listsize;}SqList;int InitList_Sq(SqList &L){// 算法2.3,构造一个空的线性表L,该线性表预定义大小为LIST_INIT_SIZE // 请补全代码L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return 0;}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){// 算法2.4,在顺序线性表L中第i个位置之前插入新的元素e// i的合法值为1≤i≤L.length +1// 请补全代码ElemType *newbase,*p,*q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+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){// 算法2.5,在顺序线性表L中删除第i个位置的元素,并用e返回其值// i的合法值为1≤i≤L.length// 请补全代码ElemType *p,*q;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"); // 判断i值是否合法,请填空else printf("The Element %d is Successfully Inserted!\n", x);break;case 2: scanf("%d",&i);if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法,请填空else printf("The Element %d is Successfully Deleted!\n", e);break;case 3: Load_Sq(T);break;case 0: return 1;}}}解法二:(C++STL list)#include<stdio.h>#include<malloc.h>#include<list>using namespace std;int main(){list<int> T;int a, i;int e, x;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(i<1||i>(int)T.size()+1) printf("Insert Error!\n"); // 判断i值是否合法else{int j=1,p=0;list<int>::iterator iter=T.begin();if(i==1){T.push_front(x);p=1;}while(iter!=T.end()){if(j==i&&i!=1){T.insert(iter,x);p=1;iter++;break;}else{j++;iter++;}}if(!p)T.push_back(x);printf("The Element %d is Successfully Inserted!\n", x);}break;case 2:scanf("%d",&i);if(i<1||i>(int)T.size()) printf("Delete Error!\n"); // 判断i值是否合法 else{int j=1;list<int>::iterator iter;for(iter=T.begin();iter!=T.end();++iter)if(j==i){list<int>::iterator tmp;tmp=iter;e=*iter;iter++;T.erase(tmp);break;}elsej++;}printf("The Element %d is Successfully Deleted!\n", e); }break;case 3:if(T.empty())printf("The List is empty!\n");else{list<int>::iterator plist;printf("The List is: ");for(plist = T.begin(); plist != T.end(); plist++)printf("%d ",*plist);printf("\n");}break;return 1;}}}解法三:(数组)#include<stdio.h>#include<malloc.h>#include<string.h>int main(){int T[1000];memset(T,0,sizeof(T));int a, i,k=1,e, x;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(i<1||i>k) printf("Insert Error!\n"); // 判断i值是否合法,请填空else{for(int j=k-1; j>=i; j--)T[j+1]=T[j];T[i]=x;k++;printf("The Element %d is Successfully Inserted!\n", x);}break;case 2:scanf("%d",&i);if(i<1||i>k-1) printf("Delete Error!\n"); // 判断i值是否合法,请填空 else{e=T[i];for(int j=i; j<k; j++)T[j]=T[j+1];k--;printf("The Element %d is Successfully Deleted!\n", e);}break;case 3:if(k==1) printf("The List is empty!");else{printf("The List is: ");for(int j=1; j<k; j++) printf("%d ",T[j]);}printf("\n");break;case 0:return 1;}}}8577 合并顺序表时间限制:1000MS 内存限制:1000K提交次数:5339 通过次数:2251题型: 编程题语言: 无限制Description编写算法,将两个非递减有序顺序表A和B合并成一个新的非递减有序顺序表C。

《华南农业大学期末考试试卷》-数据结构-A卷

《华南农业大学期末考试试卷》-数据结构-A卷

华南农业大学期末考试试卷(A卷)2011-2012学年第1 学期考试科目:数据结构(JA V A)考试类型:(闭卷)考试考试时间:120分钟学号姓名年级专业2010级信管班答案请写到答题纸上,写在试卷上无效一、单选题(本大题共10小题,每小题2分,共20分)1.不考虑优先队列,已知入队序列为{A,B,C,D},可能的出队序列为:()A. {D,B,C,A}B. {A,B,C,D}C. {A,D,C,B}D. {A,C,D,B}2.已知结点数为1001的完全二叉树,其叶子结点个数为:()A.500B.501C.602D.13.具有8000个结点的二叉树,其高度至少为:()A.10B.11C. 12D.134.设一棵哈夫曼树有n个非叶子结点,该树共有()个节点A.nB.2n-1C.2n+1D. 2n5.归并排序的空间复杂度是:()A. O(nlog2n)B. O(n2)C. O(log2n)D. O(n)6.以下程序时间复杂度为:()int n=8,m=1024,count=1024;for (int i=m; i>=1; i--)count++;A.O(1)B. O(m)C. O(log2m)D. O(mlog2m)7.式n+log2n+n*n*n的时间复杂度为:()A.O(1)B. O(n3)C. O(n+log2n)D. O(log2n)8.衡量算法的标准有:()A.时间复杂度和空间复杂度B.输入和输出C.有穷性和确定性D.可行性9.已知入栈顺序为{a,b,c,d,e,f,g},下列哪个是可能的出栈顺序:()A. {d,e,c,f,b,g,a}B. {f,e,g,d,a,c,b}C. {e,f,d,g,b,c,a}D. { e,f,d,g,b,a,c }10.已知一个顺序循环队列最多能容纳60个元素,当前有58个元素时,如果再插入5个元素,该队列有多少空元素:()A.-3B.63C.5D.57二、填空题(本大题共10小题,每空1分,共20分)1.软件设计是计算机学科各个领域的核心。

2012.1数据结构答案(A)

2012.1数据结构答案(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、参考答案: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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  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\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d%d",&i,&x);if(_________________________) printf("Insert Error!\n"); 1:Insert element 2: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 9 1: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),设计一个算法,将线性表逆置,要求线性表仍占用原线性表的空间。

相关文档
最新文档