华农数据结构部分答案

合集下载

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

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

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

《数据结构》课后习题答案(第2版)

《数据结构》课后习题答案(第2版)

《数据结构》课后习题答案(第2版)数据结构课后习题答案(第2版)第一章:基本概念1. 什么是数据结构?数据结构是指数据元素之间的关系,以及相应的操作。

它研究如何组织、存储和管理数据,以及如何进行高效的数据操作。

2. 数据结构的分类有哪些?数据结构可以分为线性结构和非线性结构。

线性结构包括数组、链表、栈和队列;非线性结构包括树和图。

3. 什么是算法?算法是解决特定问题的一系列有序步骤。

它描述了如何输入数据、处理数据,并产生期望的输出结果。

4. 算法的特性有哪些?算法具有确定性、有限性、输入、输出和可行性这五个特性。

5. 数据结构和算法之间的关系是什么?数据结构是算法的基础,算法操作的对象是数据结构。

第二章:线性表1. 顺序表的两种实现方式是什么?顺序表可以通过静态分配或动态分配的方式实现。

静态分配使用数组,动态分配使用指针和动态内存分配。

2. 单链表的特点是什么?单链表由节点组成,每个节点包含数据和一个指向下一个节点的指针。

它的插入和删除操作效率高,但是查找效率较低。

3. 循环链表和双向链表分别是什么?循环链表是一种特殊的单链表,在尾节点的指针指向头节点。

双向链表每个节点都有一个指向前一个节点和后一个节点的指针。

4. 链表和顺序表的区别是什么?链表的插入和删除操作效率更高,但是查找操作效率较低;顺序表的插入和删除操作效率较低,但是查找操作效率较高。

第三章:栈和队列1. 栈是什么?栈是一种特殊的线性表,只能在表的一端进行插入和删除操作。

后进先出(LIFO)是栈的特点。

2. 队列是什么?队列是一种特殊的线性表,只能在表的一端进行插入操作,在另一端进行删除操作。

先进先出(FIFO)是队列的特点。

3. 栈和队列的应用有哪些?栈和队列在计算机科学中有广泛的应用,例如浏览器的前进后退功能使用了栈,操作系统的进程调度使用了队列。

4. 栈和队列有哪些实现方式?栈和队列可以使用数组或链表来实现,还有更为复杂的如双端队列和优先队列。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

华南农业大学期末考试试卷及参考答案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、数据的安全性是指____________。

2、设某数据库中有作者表(作者号,城市)和出版商表(出版商号,城市),请补全如下查询语句,使该查询语句能查询作者和出版商所在的全部不重复的城市。

SELECT城市FROM作者表_____SELECT城市FROM出版商表;3、在SELECT命令中进行查询,若希望查询的结果不出现重复元组,应在SEL ECT语句中使用______保留字。

4、在SQL Server 2000中,某数据库用户User在此数据库中具有对T 表数据的查询和更改权限。

现要收回User对T表的数据更改权,下述是实现该功能的语句,请补全语句。

_____UPDATE ON T FROM User;5、数据库管理系统的主要功能有______________、______________、数据库的运行管理以及数据库的建立和维护等4个方面。

6、某事务从账户A转出资金并向账户B转入资金,此操作要么全做,要么全不做,为了保证该操作的完整,需要利用到事务性质中的_____性。

7、SQL Server中数据完整性包括______、______和______。

8、设有关系模式R(A,B,C)和S(E,A,F),若R.A是R的主码,S.A是S的外码,则S.A的值或者等于R中某个元组的主码值,或者______取空值,这是规则,它是通过______和______约束来实现的。

9、数据库系统是利用存储在外存上其他地方的______来重建被破坏的数据库。

方法主要有两种:______和______。

10、数据仓库创建后,首先从______中抽取所需要的数据到数据准备区,在数据准备区中经过净化处理______,再加载到数据仓库中,最后根据用户的需求将数据发布到______。

二、判断题11、外模式DDL用来描述数据库的总体逻辑结构。

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

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

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

《数据结构》课后参考答案

《数据结构》课后参考答案

《数据结构》课后参考答案第一题:1. 什么是数据结构?数据结构是一种组织和存储数据的方式,它涉及到数据的逻辑关系、数据元素之间的操作和存储方式等。

数据结构可以帮助我们更有效地组织和管理数据,提高程序的运行效率。

第二题:2. 请简述线性表和链表的区别。

线性表是一种线性结构,其中的数据元素按照线性的顺序排列。

线性表可以使用数组实现,也可以使用链表实现。

链表是一种动态数据结构,它通过节点之间的指针连接来存储数据元素。

主要区别:- 存储方式:线性表使用静态的连续内存空间存储,而链表使用动态的节点存储,并通过指针连接节点。

- 插入和删除操作:线性表需要移动数组中的元素,而链表只需要修改指针指向即可。

- 访问效率:线性表可以通过下标直接访问元素,访问效率高;链表需要从头节点开始逐个遍历,访问效率较低。

第三题:3. 请描述栈和队列的特点及其应用场景。

栈和队列都是常用的线性数据结构,它们在不同的场景中有着不同的特点和应用。

栈的特点:- 先进后出(LIFO)的数据结构。

- 只能在栈顶进行插入和删除操作。

- 用途广泛,如函数调用、表达式求值、计算机内存的管理等。

队列的特点:- 先进先出(FIFO)的数据结构。

- 可以在队尾插入元素,在队头删除元素。

- 用途广泛,如任务调度、消息传递、广度优先搜索等。

第四题:4. 请简述树和图的区别以及它们的应用场景。

树和图都是常用的非线性数据结构,它们之间有着一些区别和各自的应用场景。

树的特点:- 由节点和边组成的层次结构。

- 每个节点最多有一个父节点和多个子节点。

- 常用的树结构有二叉树、平衡二叉树、B树等。

- 应用场景包括文件系统、数据库索引等。

图的特点:- 由节点和边组成的非线性结构。

- 节点之间的关系可以是任意的。

- 常用的图结构有有向图、无向图、加权图等。

- 应用场景包括社交网络、路由算法、拓扑排序等。

综上所述,数据结构是计算机科学的重要基础,它为我们解决实际问题提供了有力的工具和方法。

2022年华南农业大学信息管理与信息系统专业《数据库概论》科目期末试卷B(有答案)

2022年华南农业大学信息管理与信息系统专业《数据库概论》科目期末试卷B(有答案)

2022年华南农业大学信息管理与信息系统专业《数据库概论》科目期末试卷B(有答案)一、填空题1、以子模式为框架的数据库是______________;以模式为框架的数据库是______________;以物理模式为框架的数据库是______________。

2、数据库内的数据是______的,只要有业务发生,数据就会更新,而数据仓库则是______的历史数据,只能定期添加和刷新。

3、在关系数据库的规范化理论中,在执行“分解”时,必须遵守规范化原则:保持原有的依赖关系和______。

4、事务故障、系统故障的恢复是由______完成的,介质故障是由______完成的。

5、“为哪些表,在哪些字段上,建立什么样的索引”这一设计内容应该属于数据库设计中的______阶段。

6、数据库系统在运行过程中,可能会发生各种故障,其故障对数据库的影响总结起来有两类:______和______。

7、在SELECT命令中进行查询,若希望查询的结果不出现重复元组,应在SEL ECT语句中使用______保留字。

8、数据模型是由______________、______________和______________三部分组成。

9、在RDBMS中,通过某种代价模型计算各种查询的执行代价。

在集中式数据库中,查询的执行开销主要包括______和______代价。

在多用户数据库中,还应考虑查询的内存代价开销。

10、使某个事务永远处于等待状态,得不到执行的现象称为______。

有两个或两个以上的事务处于等待状态,每个事务都在等待其中另一个事务解除封锁,它才能继续下去,结果任何一个事务都无法执行,这种现象称为______。

二、判断题11、有两个关系R和S,分别包含15个和10个元组,则在R∪S、R-S、R∩S中可能出现的一种元组数目情况是18、7、7()12、在SQL中,ALTERTABLE语句中MODIFY用于修改字段的类型和长度等,ADD用于添加新的字段。

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

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

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

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

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

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

第二章线性表习题一:给定一个顺序表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创建一个空的循环队列,并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。

《华南农业大学期末考试试卷》-数据结构-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. 题目:给定一个整数数组,判断是否存在两个元素之和等于目标值。

答案:使用双指针法,首先将数组排序,然后设置左指针指向数组头部,右指针指向数组尾部。

如果左指针和右指针指向的元素之和小于目标值,则左指针右移;如果大于目标值,则右指针左移;如果等于目标值,则找到了两个元素之和等于目标值的情况。

2. 题目:给定一个整数数组和一个目标值,找出数组中和为目标值的两个数的下标。

答案:使用哈希表,在遍历数组的过程中,将每个元素的值和下标存储在哈希表中。

遍历到当前元素时,检查目标值与当前元素的差值是否在哈希表中,如果存在,则找到了两个数的下标。

---第二章:链表1. 题目:给定一个链表,判断链表中是否存在环。

答案:使用快慢指针法,定义两个指针,一个指针每次向前移动一个节点,另一个指针每次向前移动两个节点。

如果存在环,则两个指针必定会相遇。

2. 题目:给定一个链表,删除链表的倒数第N个节点。

答案:使用双指针法,定义两个指针,一个指针先移动N个节点,然后两个指针同时向前移动,直到第一个指针到达链表尾部。

此时第二个指针指向的节点即为要删除的节点。

---第三章:栈和队列1. 题目:设计一个栈,使得可以在常数时间内获取栈中的最小元素。

答案:使用辅助栈来保存当前栈中的最小元素。

每次压栈操作时,将当前元素与辅助栈的栈顶元素比较,只有当前元素较小才将其压入辅助栈。

2. 题目:设计一个队列,使得可以在常数时间内获取队列中的最大元素。

答案:使用双端队列来保存当前队列中的最大值。

每次入队操作时,将当前元素与双端队列的末尾元素比较,只有当前元素较大才将其压入双端队列。

---第四章:树和二叉树1. 题目:给定一个二叉树,判断它是否是平衡二叉树。

答案:通过递归遍历二叉树的每个节点,计算每个节点的左子树高度和右子树高度的差值。

如果任意节点的差值大于1,则该二叉树不是平衡二叉树。

2009数据结构期末A答案

2009数据结构期末A答案

华中农业大学本科课程考试试卷答案及评分标准考试课程与试卷类型:数据结构(期末A ) 学年学期:2009.2-2009.7 考试日期:一、单项选择题 (每题2分,共20分)二、判断正误:(正确在( )内打√,否则打 。

每小题1分,共5分)( )(1) ( )(2) (√)(3) ( )(4) ( )(5)三、填空题. (将答案写在该题( )里。

每( )2分,共12分)1.完全 2. 平衡 3.排序 4.深度优先 广度优先 队列四、解答题(本题满分44分)。

1.解:(满分9分,每错一个关键字,扣1分)2.解:(满分9分,其中哈夫曼树占7分,每错一处扣1分;带权路径长度正确再给2分)。

WPL=8×3+4×4+5×4+16×2+9×3+12×3+26×2=2073.解:(1)□,50,15,30,85,12,20,70 ....................2分 20, 50,15,30,85,12,□,70 ……………………… 1分 20,□,15,30,85,12,50,70 …………………………1分 20, 12,15,30,85,□,50,70 …………………………1分 20, 12,15, 30,□,85,50,70 ………………………1分(20,12,15,30,)35, (85, 50, 70) ………………………1分(2)(35),50,15,30,85,12,20,70 ……………………1分(35, 50),15,30,85,12,20,70(15,35,50),30,85,12,20,70 ……………………1分(15,30,35,50),85,12,20,70(15,30, 35, 50 ,85),12, 20, 70 ……………………1分 (12, 15, 30, 35, 50 ,85), 20,70(12, 15 ,20, 30, 35, 50, 85), 70 ……………………1分 (12, 15, 20, 30, 35, 50, 70, 85) ……………………1分4、解:(满分7分,每错一步,扣1分)5、解(满分7分,每错1步扣1.5分)五、程序填空题:(请阅读下面拓扑排序算法程序,完成填空,将答案写在该题横线上 ,每空3分,本题满分9分)。

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

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

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{i nt *elem;i nt length;i nt listsize;}SqList;int InitList_Sq(SqList &L){n");}w hile(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{i nt *elem;i nt length;i nt listsize;}SqList;int InitList_Sq(SqList &L) {n");}w hile(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d%d",&i,&x);if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); 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)。

(完整版) 《数据结构》教材课后习题+答案

(完整版) 《数据结构》教材课后习题+答案

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

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

3.简述逻辑结构的四种基本关系并画出它们的关系图。

4.存储结构由哪两种基本的存储方法实现?5.选择题(1)在数据结构中,从逻辑上可以把数据结构分成()。

A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构(2)与数据元素本身的形式、内容、相对位置、个数无关的是数据的()。

A.存储结构B.存储实现C.逻辑结构D.运算实现(3)通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着()。

A.数据具有同一特点B.不仅数据元素所包含的数据项的个数要相同,而且对应数据项的类型要一致C.每个数据元素都一样D.数据元素所包含的数据项的个数要相等(4)以下说法正确的是()。

A.数据元素是数据的最小单位B.数据项是数据的基本单位C.数据结构是带有结构的各数据项的集合D.一些表面上很不相同的数据可以有相同的逻辑结构(5)以下与数据的存储结构无关的术语是()。

A.顺序队列 B. 链表 C. 有序表 D. 链栈(6)以下数据结构中,()是非线性数据结构A.树B.字符串C.队D.栈6.试分析下面各程序段的时间复杂度。

(1)x=90; y=100;while(y>0)if(x>100){x=x-10;y--;}else x++;(2)for (i=0; i<n; i++)for (j=0; j<m; j++)a[i][j]=0;(3)s=0;for i=0; i<n; i++)for(j=0; j<n; j++)s+=B[i][j];sum=s;(4)i=1;while(i<=n)i=i*3;(5)x=0;for(i=1; i<n; i++)for (j=1; j<=n-i; j++)x++;(6)x=n; //n>1y=0;while(x≥(y+1)* (y+1))y++;(1)O(1)(2)O(m*n)(3)O(n2)(4)O(log3n)(5)因为x++共执行了n-1+n-2+……+1= n(n-1)/2,所以执行时间为O(n2)(6)O(n)第2章线性表1.选择题(1)一个向量第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是()。

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

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

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

A.图的遍历是从给定的源点出发每个顶点仅被访问一次B.遍历的基本方法有两种:深度遍历和广度遍历C.图的深度遍历不适用于有向图D.图的深度遍历是一个递归过程2、用数组r存储静态链表,结点的next域指向后继,工作指针j指向链中结点,使j沿链移动的操作为()。

A.j=r[j].nextB.j=j+lC.j=j->nextD.j=r[j]->next3、某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用()存储方式最节省运算时间。

A.单链表B.仅有头指针的单循环链表C.双链表D.仅有尾指针的单循环链表4、最大容量为n的循环队列,队尾指针是rear,队头:front,则队空的条件是()。

A.(rear+1)MOD n=frontB.rear=frontC.rear+1=frontD.(rear-1)MOD n=front5、下面关于串的叙述中,不正确的是()。

A.串是字符的有限序列B.空串是由空格构成的串C.模式匹配是串的一种重要运算D.串既可以采用顺序存储,也可以采用链式存储6、若元素a,b,c,d,e,f依次进栈,允许进栈、退栈操作交替进行,但不允许连续三次进行退栈操作,则不可能得到的出栈序列是()。

7、下列关于无向连通图特性的叙述中,正确的是()。

Ⅰ.所有的顶点的度之和为偶数Ⅱ.边数大于顶点个数减1 Ⅲ.至少有一个顶点的度为1A.只有Ⅰ B.只有Ⅱ C.Ⅰ和Ⅱ D.Ⅰ和Ⅲ8、一棵哈夫曼树共有215个结点,对其进行哈夫曼编码,共能得到()个不同的码字。

A.107B.108C.214D.2159、一个具有1025个结点的二叉树的高h为()。

A.11B.10C.11至1025之间D.10至1024之间10、就平均性能而言,目前最好的内排序方法是()排序法。

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

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

2022年华中农业大学数据科学与大数据技术专业《计算机系统结构》科目期末试卷A(有答案)一、选择题1、全相联地址映象是指()。

A.任何虚页都可装入主存中任何实页的位置B.一个虚页只装进固定的主存实页位置C.组之间是固定的,而组内任何虚页可以装入任何实页位置D.组间可任意装入,组内是固定装入2、对汇编语言程序员透明的是()A.I/O方式中的DMA访问B.浮点数据表示C.访问方式保护D.程序性中断3、CRAY-I的流水线是( )A.多条单功能流水线B.一条单功能流水线C.多条多功能流水线D.一条多功能流水线4、从计算机系统结构上讲,机器语言程序员所看到的机器属性是( )。

A.计算机软件所要完成的功能B.计算机硬件的全部组成C.编程要用到的硬件组织D.计算机各部件的硬件实现5、流水机器对全局性相关的处理不包括( )A.猜测法B.提前形成条件码C.加快短循环程序的执行D.设置相关专用通路6、多处理机的各自独立型操作系统()。

A.要求管理程序不必是可再入的B.适合于紧耦合多处理机C.工作负荷较平衡D.有较高的可靠性7、若输入流水线的指令既无局部性相关,也不存在全局性相关,则()。

A.可获得高的吞吐率和效率B.流水线的效率和吞吐率恶化C.出现瓶颈D.可靠性提高8、下列关于标量流水机的说法不正确的是()A.可对标量数据进行流水处理B.没有向量数据表示C.不能对向量数据进行运算D.可以对向量、数组进行运算9、在操作系统机器级,一般用()程序()作业控制语句。

A.汇编程序,翻译B.汇编程序,解释C.机器语言,解释D.机器语言,翻译10、对系统程序员不透明的应当是()A.CACHE 存储器B.系列机各档不同的数据通路宽度C.指令缓冲寄存器D.虚拟存储器二、填空题11、设计指令系统时,在功能方面的基本要求是:指令系统的完整性、________、高效率和兼容性。

12、向量指令可分为________和________13、指令由________和________组成。

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

华农数据结构部分答案8576 顺序线性表的基本操作 #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) {L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if (!L.elem){return ERROR; }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, ElemType e) {int *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));if(!newbase){return ERROR;}L.elem = newbase;L.listsize += LISTINCREMENT;}q = &(L.elem[i-1]);= &(L.elem[L.length-1]); p >= q; --p) for (p{*(p+1) = *p;}*q = e;L.length++;return OK;}int ListDelete_Sq(SqList &L,int i, ElemType &e) {int *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"); }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");}else{printf("The Element %d is Successfully Deleted!\n",e);}break;case 3:Load_Sq(T);break;case 0:return 1;}}}8577 合并顺序表#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){L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!L.elem) return ERROR;L.length=0;L.listsize=LIST_INIT_SIZE; return OK;}void Load_Sq(SqList &L,char name) {int i;if(L.length==0) printf("The List is empty!");else{printf("List %c:",name);for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);}printf("\n");}int ListInsert_Sq(SqList &L,int e) {ElemType *newbase,*p;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(El emType));if(!newbase) return ERROR;L.elem=newbase; L.listsize+=LISTINCREMENT;}p=&(L.elem[L.length]);*p=e;++L.length;return OK;}int MergeList_Sq(SqList La,SqList Lb,SqList &Lc){int *pa,*pb,*pc,*pa_last,*pb_last;pa=La.elem;pb=Lb.elem;Lc.listsize=Lc.length=La.length+Lb.length;pc=Lc.elem=(ElemType *)malloc(Lc.listsize*sizeof(ElemType));if(!Lc.elem) return ERROR; pa_last=La.elem+La.length-1;pb_last=Lb.elem+Lb.length-1; while(pa<=pa_last&&pb<=pb_last){ if(*pa<=*pb) *pc++=*pa++;else *pc++=*pb++;}while(pa<=pa_last) *pc++=*pa++;while(pb<=pb_last) *pc++=*pb++;return OK;}int main(){SqList A,B,C;int n,i;ElemType x;InitList_Sq(A);InitList_Sq(B);InitList_Sq(C);char name[]={'A','B','C'}; scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&x);ListInsert_Sq(A,x);}scanf("%d",&n);for(i=0;i<n;i++){scanf("%d",&x);ListInsert_Sq(B,x);}MergeList_Sq(A,B,C);Load_Sq(A,name[0]);Load_Sq(B,name[1]);Load_Sq(C,name[2]); } 8578 顺序表逆置#include <stdio.h>#include <malloc.h>#define ERROR 0#define OK 1#define ElemType int typedef struct LNode{ElemType 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 = L;for (i = 0; i < n; i++) {scanf("%d",&e);p = (LinkList)malloc(sizeof(LNode));p->data = e; p->next = NULL;q->next = p;q = p;}return OK;}int LoadLink_L(LinkList &L, char name[]) {LinkList p = L->next;if (!p){printf("The List is empty!");}else{printf("The%sList is:",name);while (p){printf("%d ",p->data);p = p->next;}}printf("\n");return OK;}int LinkInsert_L(LinkList &L, int i, ElemType e) {LinkList s, p = L; 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;->next; s->next = pp->next = s;return OK;}int ListDelete_L(LinkList &L, int i, ElemType &e) {LinkList q, p = L;int j = 0;while(p && j < i - 1){p = p->next; j++;}if(!p || j > i - 1){return ERROR;}q = p->next;p->next = q->next;e = q->data;free(q);return OK;}void ListTurn_L(LinkList &L) {LinkList p_current, p_last, p;p = p_current = L;p_last = L->next;if (p_last->next == NULL){return;}while ((p_current->next)->next !=NULL) {while(p_last->next != NULL){p_last = p_last->next;p = p->next;}ext = NULL; p->np_last->next = p_current->next;p_current->next = p_last;p_current = p_last;p_last = p_last->next;p = p_current;}}int main(){LinkList T;int num;scanf("%d",&num);CreateLink_L(T,num);LoadLink_L(T," ");ListTurn_L(T);LoadLink_L(T," turned ");return OK;}8579 链式线性表的基本操作#include <stdio.h>#include <malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{ElemType 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 = L;for (i = 0; i < n; i++) {scanf("%d",&e);p = (LinkList)malloc(sizeof(LNode)); p->data = e; p->next = NULL;q->next = p;q = p;}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) {LinkList s, p = L; 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 ListDelete_L(LinkList &L, int i, ElemType &e) {LinkList q, p = L; 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:Loadall 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");}else{printf("The Element %d is Successfully Inserted!\n",x); }break;case 2:scanf("%d",&i);if(!ListDelete_L(T, i, e)){printf("Delete Error!\n");}else{printf("The Element %d is Successfully Deleted!\n",e); }break;case 3:LoadLink_L(T);break;case 0:return 1;}}}8580 合并链表#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=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=p;}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 A,B,C;int n;scanf("%d",&n);CreateLink_L(A,n);scanf("%d",&n);CreateLink_L(B,n); printf("List A:"); LoadLink_L(A);printf("List B:");LoadLink_L(B);MergeList_L(A,B,C);printf("List C:");LoadLink_L(C); }8581 线性链表逆置#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){L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if (!L.elem){return ERROR;}L.length = 0;L.listsize = LIST_INIT_SIZE; return OK;}int Load_Sq(SqList &L, char name[]) {int i;if (L.length==0){printf("The List is empty!");}else{printf("The%sList is:", name);for (i = 0; i < L.length; i++){printf("%d ",L.elem[i]);}}printf("\n");return OK;}int ListInsert_Sq(SqList &L, int i, ElemType e) {int *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));if(!newbase){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 ListDelete_Sq(SqList &L,int i, ElemType &e) {int *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;}void ListTurn(SqList &L) {int i;ElemType temp;for(i = L.length - 1; i > L.length - i - 1; i--) {temp = L.elem[i];L.elem[i] = L.elem[L.length - i - 1];L.elem[L.length - i - 1] = temp;}}int main(){SqList T;int num, i;ElemType e;InitList_Sq(T);scanf("%d",&num);for (i = 1; i <= num; i++){scanf("%d",&e);ListInsert_Sq(T, i, e);}Load_Sq(T," ");ListTurn(T);Load_Sq(T," turned ");return OK;}8583 顺序栈的基本操作#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef 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,(STACK_INIT_SIZE+STACKINCREMENT)*sizeof(SElemType));if(!S.base)return ERROR;S.top = S.base +S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){if(S.top == S.base)return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){if(S.top == S.base)return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S) {return S.top-S.base; }Status StackTraverse(SqStack S) {SElemType *p;p=S.top;if(S.top == S.base)printf("The Stack is Empty!"); else{printf("The Stack is:");p--;while(p>=S.base){printf(" %d",*p);p--;}}printf("\n");return OK;}int main(){int a ;SqStack S;SElemType x,e;if(InitStack(S)){printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack \n5:Load the Stack \n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1:scanf("%d",&x);if(!Push(S,x))printf("Push Error!\n");else printf("The Element %d is Successfully Pushed!\n",x);break;case 2:if(!Pop(S,e))printf("Pop Error!\n");else printf("The Element %d is Successfully Poped!\n",e);break;case 3:if(!GetTop(S,e))printf("Get Top Error!\n");else printf("The Top Element is %d!\n",e);break;case 4:printf("The Length of the Stack is %d!\n",StackLength(S)); break;case 5:StackTraverse(S);break;case 0:return 1;}}}8585 栈的应用——进制转换#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef int SElemType; typedef int Status;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 Pop(SqStack &S,SElemType &e) {if(S.top ==S.base ) return ERROR;e=*--S.top ;return OK;}Status Push(SqStack &S,SElemType e) {if(S.top -S.base >=S.stacksize ){S.base =(SElemType *)realloc(S.base ,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S.base) return ERROR; S.top =S.base +S.stacksize ;S.stacksize +=STACKINCREMENT;}*S.top ++=e;return OK;}Status StackEmpty(SqStack &S){if(S.base==S.top) return 1; else return ERROR;}void conversion(){SqStack S;int n;SElemType e;InitStack(S);scanf("%d",&n);while(n){Push(S,n%8);n=n/8;}while(!StackEmpty(S)){ Pop(S,e);printf("%d",e);}}int main(){conversion();}8591 计算next值#include <stdio.h>#include <stdlib.h>#define MAXSTRLEN 255 // 用户可在255以内定义最大串长typedef unsigned char SString[MAXSTRLEN+1]; // 0号单元存放串的长度void get_next(SString T,int next[]){ // 求模式串T的next函数值并存入数组nextint i,j;i=1;j=0;next[1]=0;while(i<T[0]){if(j==0||T[i]==T[j]){ ++i;++j;next[i]=j;}else j=next[j];}}//get_nextvoid main(){int next[MAXSTRLEN];SString S;int n,i,j;char ch;scanf("%d",&n); // 指定要验证NEXT值的字符串个数ch=getchar();for(i=1;i<=n;i++){ch=getchar();for(j=1;j<=MAXSTRLEN&&(ch!='\n');j++) // 录入字符串{S[j]=ch;ch=getchar();}S[0]=j-1; // S[0]用于存储字符串中字符个数get_next(S,next);printf("NEXT J is:");for(j=1;j<=S[0];j++)printf("%d",next[j]);printf("\n");}}8592 KMP算法#include <stdio.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASLBLE -1#define OVERFLOW -2#define MAXSTRLEN 255 //用户可在255以内定义最大串长typedef unsigned char SString[MAXSTRLEN+1]; //0号单元存放串的长度void get_next(SString T,int next[]){ // 算法4.7// 求模式串T的next函数值并存入数组nextint i,j;i=1;j=0;=0; next[1]while(i<T[0]){if(j==0||T[i]==T[j]){++i;++j;next[i]=j;}else j=next[j];}}int Index_KMP(SString S,SString T,int pos){// 算法4.6// 利用模式串T的next函数求T在主串S中第pos个字符之后的位置 int i,j,next[MAXSTRLEN];i=pos;j=1;get_next(T,next);while(i<=S[0]&&j<=T[0]){if(j==0||S[i]==T[j]){++i;++j;}else j=next[j];}if(j>T[0]) return i-T[0];else return 0;}//Index_KMPvoid main(){SString T,S;int i,j,n;char ch;int pos;scanf("%d",&n); // 指定n对需进行模式匹配的字符串ch=getchar();for(j=1;j<=n;j++){ch=getchar();for( i=1;i<=MAXSTRLEN&&(ch!='\n');i++) // 录入主串 {S[i]=ch;ch=getchar();}S[0]=i-1; // S[0]用于存储主串中字符个数ch=getchar();for( i=1;i<=MAXSTRLEN&&(ch!='\n');i++) // 录入模式串{T[i]=ch;ch=getchar();}T[0]=i-1; // T[0]用于存储模式串中字符个数pos= Index_KMP(S,T,1); // 请填空printf("%d\n",pos); }}8606 二叉树的构建及遍历操作 #include<stdio.h>#include<malloc.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1 #define OVERFLOW -2typedef int Status;typedef char ElemType;typedef struct BiTNode{ElemType data;struct BiTNode *lchild,*rchild;//左右孩子指针 }BiTNode,*BiTree; BiTree CreateBiTree(BiTree &T){char ch;scanf("%c",&ch);if(ch=='#') T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;T->data = ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return T;}Status PrintElement(ElemType e){printf("%c",e);return OK;}Status PreOrderTraverse(BiTree T,Status(*Visit)(ElemType)){ if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit)) if(PreOrderTraverse(T->rchild,Visit))return OK;return ERROR;}else return OK;}Status InOrderTraverse(BiTree T,Status(*Visit)(ElemType)){ if(T){if(InOrderTraverse(T->lchild,Visit))if(Visit(T->data))if(InOrderTraverse(T->rchild,Visit))return OK;return ERROR;}else return OK;}Status PostOrderTraverse(BiTree T,Status(*Visit)(ElemType)){ if(T){if(PostOrderTraverse(T->lchild,Visit))if(PostOrderTraverse(T->rchild,Visit))if(Visit(T->data))return OK;return ERROR;}else return OK;}int main(){BiTree T;CreateBiTree(T);PreOrderTraverse(T,PrintElement);printf("\n");InOrderTraverse(T,PrintElement);printf("\n");PostOrderTraverse(T,PrintElement);printf("\n");}8607 实现二叉排序树的各种算法(1) #include<stdio.h>#include<malloc.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10typedef int Status;typedef int ElemType;typedef struct BiTNode{ElemType key;struct BiTNode *left,*right;//左右孩子指针 }BiTNode,*BiTree; BiTree InsertBiT(BiTree T,ElemType key) {BiTree f,p=T;while(p){if(p->key==key) return NULL;f=p;p=(key<p->key)?p->left:p->right; }p=(BiTree)malloc(sizeof(BiTNode)); p->key=key;p->left=p->right=NULL;if(T==NULL)T=p;elseif(key<f->key) f->left=p;elsef->right=p;return T;}BiTree CreateBiT(){BiTree T=NULL;ElemType key;int n,i;scanf("%d",&n);for(i=1;i<=n;i++){scanf("%d",&key);T=InsertBiT(T,key);}return T;}void preorder_btree(BiTree root) { BiTree p=root;if(p!=NULL){printf("%d ",p->key);preorder_btree(p->left);preorder_btree(p->right);}}void inorder_btree(BiTree root) {BiTree p=root;if(p!=NULL){inorder_btree(p->left );printf("%d ",p->key );inorder_btree(p->right );}}void postorder_btree(BiTree root) {BiTree p=root;if(p!=NULL){postorder_btree(p->left );postorder_btree(p->right );printf("%d ",p->key );}}Status visit(BiTree p){printf("%d ",p->key); return OK;}//栈typedef BiTree SElemType;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)*sizeof(SElemType));if(!S.base) return ERROR;S.top =S.base +S.stacksize ;S.stacksize +=STACKINCREMENT;}*S.top ++=e;return OK;}Status Pop(SqStack &S,SElemType &e) {if(S.top ==S.base ) return ERROR;e=*--S.top ;return OK;}Status StackEmpty(SqStack &S){ if(S.base==S.top) return TRUE; else return FALSE;}Status InOrderTraverse(BiTree T) {//非递归中序SqStack S;InitStack(S);BiTree p=T;while(p||!StackEmpty(S)){if(p){Push(S,p);p=p->left;}else{Pop(S,p);if(!visit(p)) return ERROR;p=p->right;}}return OK;}int treedepth(BiTree bt){int hl,hr,max;if(bt!=NULL){hl=treedepth(bt->left);hr=treedepth(bt->right);max=(hl>hr)?hl:hr; return (max+1); }elsereturn 0;}int count=0;int leafcount(BiTree bt){if(bt!=NULL){leafcount(bt->left);leafcount(bt->right);if(bt->left==NULL&&bt->right==NULL) count++;}return count;}void paintleaf(BiTree bt) {if(bt!=NULL){if(bt->left==NULL&&bt->right==NULL)printf("%d ",bt->key);paintleaf(bt->left); paintleaf(bt->right); }}BiTNode *searchBiT(BiTree t,ElemType key) {if(t==NULL||key==t->key) return t;if(key<t->key)return searchBiT(t->left,key);elsereturn searchBiT(t->right,key); }typedef BiTree QElemType ;typedef struct QueueNode{QElemType data;struct QueueNode *next; } QueueNode; typedef struct linkQueue{e * front; QueueNodQueueNode * rear;}linkQueue;void initQueue(linkQueue * q) {q->front=q->rear =NULL; //----无头结点 }int QueueEmpty(linkQueue * Q) {return (Q->front==NULL)&&(Q->rear==NULL);}void EnQueue(linkQueue *Q,QElemType x) {QueueNode *p=(QueueNode *)malloc(sizeof(QueueNode)); p->data=x; p->next=NULL;if(QueueEmpty(Q)) //----无头结点 Q->front=Q->rear=p; else{Q->rear->next=p; Q->rear=p; }}QElemType DeQueue (linkQueue *Q) {QElemType x;QueueNode *p;if(QueueEmpty(Q)){printf("Queue underflow");return ERROR;}p=Q->front;x=p->data; Q->front=p->next;if(Q->rear==p)Q->rear=NULL;free(p);return x;}void breadthFirst2(BiTree root) {BiTree p,tmp;linkQueue * q;tmp=(BiTNode *)malloc(sizeof(BiTNode)); q=(linkQueue *)malloc(sizeof(linkQueue)); tmp->key=-1;initQueue(q);p=root;if(p!=NULL){EnQueue(q,p); while(!QueueEmpty(q)){p=DeQueue(q); visit(p);if(p->key!=-1){if(p->left!=NULL)EnQueue(q,p->left);else。

相关文档
最新文档