栈和队列-上机实验题
数据结构第三章堆栈和队列测试题及答案
堆栈和队列测试题一、选择题1. 对于栈操作数据的原则是（B）。
A. 先进先出B. 后进先出C. 后进后出D. 不分顺序2. 在做进栈运算时,应先判别栈是否( B),在做退栈运算时应先判别栈是否( A)。
当栈中元素为n个,做进栈运算时发生上溢,则说明该栈的最大容量为( B )。
为了增加内存空间的利用率和减少溢出的可能性,由两个栈共享一片连续的内存空间时,应将两栈的( D )分别设在这片内存空间的两端。
①, ②: A. 空 B. 满 C. 上溢 D. 下溢③: A. n-1 B. n C. n+1 D.n/2④: A. 长度 B. 深度 C. 栈顶 D. 栈底3. 一个栈的输入序列依次为1，2，3，…n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（B）。
A. 不确定B. n-i+1C. iD. n-i4. 若一个栈的输入序列为1,2,3,…,n，输出序列的第一个元素是i，则第j个输出元素是（ D ）。
A. i-j-1B. i-jC. j-i+1D. 不确定的5. 若已知一个栈的入栈序列是1,2,3,…,n，其输出序列为p1,p2,p3，…，p N,若p N是n，则pi是( D )。
A. iB. n-iC. n-i+1D. 不确定6.有六个元素6，5，4，3，2，1 的顺序进栈，问下列哪一个不是合法的出栈序列？（ C ）A. 5 4 3 6 1 2B. 4 5 3 1 2 6C. 3 4 6 5 2 1D. 2 3 4 1 5 67. 设栈的输入序列是1，2，3，4,则（ D ）不可能是其出栈序列。
A. 1，2，4，3，B. 2，1，3，4，C. 1，4，3，2，D. 4，3，1，2，E. 3，2，1，4，8. 一个栈的输入序列为1 2 3 4 5，则下列序列中不可能是栈的输出序列的是（ B ）。
A. 2 3 4 1 5B. 5 4 1 3 2C. 2 3 1 4 5D. 1 5 4 3 29. 设一个栈的输入序列是1，2，3，4，5,则下列序列中，是栈的合法输出序列的是（D）。
栈、队列练习题（答案）
栈、队列练习题（答案）栈、队列练习题一、选择题1.栈和队列的共同特点是( )。
A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.若让元素1、2、3、4依次入栈，则出栈次序不可能出现（）A．3 2 1 4 B．2 1 4 3 C．1 4 2 3 D．4 3 2 13.栈的插入和删除操作在( )进行。
A. 栈顶B. 栈底C. 任意位置D. 指定位置4.用单链表表示的链式队列的队头在链表的（）位置。
A. 链头B. 链尾C. 链中D. 以上都不是5.在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是（）。
A． p->next=s; s->prior=p;p->next->prior=s; s->next=p->next;B． s->prior=p; s->next=p->next;p->next=s; p->next->prior=s;C． p->next=s; p->next->prior=s;s->prior=p; s->next=p->next;D． s->prior=p; s->next=p->next;p->next->prior=s; p->next=s;6.设有一个栈，元素的进栈次序为A, B, C, D, E,下列是不可能的出栈序列( )。
A．A, B, C, D, E B．B, C, D, E, AC．E, A, B, C, D D．E, D, C, B, A7.在一个具有n个单元的顺序栈中，假定以地址低端（即0单元）作为栈底，以top作为栈顶指针，当做出栈处理时，top变化为( )。
A．top不变B．top=0 C．top-- D．top++8.向一个栈顶指针为hs的链栈中插入一个s结点时，应执行( )。
数据结构上机实验
目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。
队列与栈练习题
栈与队列练习题1.火车站列车调度示意图以下，假设调度站两侧的轨道为单向行驶轨道。
5,4,3,2,1 1,2,3,4,5B AC(1)如果进站的车厢序列为123，则可能的出战车厢序列是什么？(2)如果进展进站的车厢序列为123456，问能否得到135426 和435612 的出站序列。
2.模拟计算机解决算术体现式过程。
从键盘上输入算术体现式串（只含＋、－、×、÷运算符，充许含括号），输出算术体现式的值。
设输入的体现式串是正当的。
3、读入一英文句子，单词之间用空格或逗号隔开，统计其中单词个数，并输出各个字母出现的频率。
(句子末尾不一定用"."结束) 如果含有其它的字符，则只规定输出错误信息及错误类型。
含有大写字母错误类型error 1数字（0-9）错误类型error 2其它非法字符错误类型error 3如输入：It is 12!输出：error 1 2 3输入：i am ,a student输出：44、编码解码：从键盘输入一种英文句子，设计一种编码、解码程序。
(string)编码过程：先键入一种正整数N(1<=N<=26)。
这个N决定了转换关系。
例如当N=1，输入的句子为ABCXYZ时，则其转换码为ABCXYZ不变。
当N=2时，其转换码为BCDYZA，其它的非字母字符不变。
为使编码较于破译，将转换码的信息自左而右两两交换，若最后仅剩单个字符则不换。
然后，将一开始表达转换关系的N根据ascii表序号化成大写字母放在最前面。
如：abcABCxyzXYZ-/,1. n=3cdeCDEzabZAB-/,1. {根据N的值转换}dcCeEDazZbBA/-1,. {两两交换}CdcCeEDazZbBA/-1,. {最后编码}解码过程为编码的逆过程。
5.计算器的改良【第三届全国青少年信息学奥林匹克分区联赛复赛试题普及组题一】〖问题描述〗NCL是一家专门从事计算器改良与升级的实验室。
数据结构上机实验题
当涉及数据结构的上机实验题时，通常会涉及编程和算法的实践。
以下是一些可能的
上机实验题目：
1. 实现一个栈（Stack）数据结构，并编写基本的操作（入栈、出栈、获取栈顶元素等）。
2. 实现一个队列（Queue）数据结构，并编写基本的操作（入队、出队等）。
3. 实现一个链表（Linked List）数据结构，并编写插入、删除、查找等操作。
4. 实现一个二叉树（Binary Tree）数据结构，并编写遍历算法（前序、中序、后序遍历）。
5. 实现一个图（Graph）数据结构，并编写基本的图算法（深度优先搜索、广度优先搜索）。
6. 实现一个哈希表（Hash Table）数据结构，并编写插入、删除、查找等操作。
这些实验题目可以帮助学生加深对数据结构的理解，并通过编程实践来掌握数据结构
的基本操作和算法。
同时，这些实验也有助于提高学生的编程能力和解决问题的能力。
栈和队列上机实现作业
数据结构上机实验报告实验三栈和队列算法的上机实现班级：姓名：学号：实验三栈和队列算法的上机实现一、实验目的：⒈理解栈（先进后出）和队列（先进先出）的工作特点；⒉掌握栈的顺序和链式存储结构，学会进行结构定义，以及在顺序和链式存储结构下有关栈的基本操作：入栈、出栈、栈空、栈满等；3.掌握循环队列的顺序存储结构及队列的链式存储结构，学会进行结构定义，以及在顺序和链式存储结构下有关队列的基本操作：入队列、出队列、队列空、队列满等；4.应用栈和队列解决实际的问题。
二、实验内容：⒈顺序栈的基本运算⒉循环队列基本运算3.元素逆置算法的实现三、实验步骤及结果：⒈顺序栈的基本运算程序算法：#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE]; //栈中元素存储空间int top; //栈顶指针}seqstack;//顺序栈类型void init_seqstack(seqstack **s) //顺序栈初始化{*s=(seqstack*)malloc(sizeof(seqstack));//在主调函数中申请栈空间(*s)->top=-1; //置栈空标志}int empty_seqstack(seqstack *s) //判栈是否为空{if(s->top=-1) //栈为空时return 1;elsereturn 0;}void push_seqstack(seqstack *s,char x)//顺序栈元素入栈{if(s->top==MAXSIZE-1)printf("栈已满！\n"); //栈已满else{s->top++;s->data[s->top]=x; //将元素x压入栈*s中}}void pop_seqstack(seqstack *s,char *x) //将栈*s中的栈顶元素出栈并通过参数x返回给主调函数{if(s->top==-1)printf("栈为空！\n"); //栈为空else{*x=s->data[s->top]; //栈顶元素出栈s->top--;}}void top_seqstack(seqstack *s,char *x) //取顺序栈栈顶元素{if(s->top==-1)printf("栈为空！\n"); //栈为空else*x=s->data[s->top]; //取栈顶元素值}void print(seqstack *s) //顺序栈输出{int i;for(i=0;i<=s->top;i++)printf("%4c",s->data[i]);printf("\n");}void main(){seqstack *s;char x,*y=&x; //y是指向x的指针，出栈元素经过y传给变量xinit_seqstack(&s); //顺序栈初始化if(empty_seqstack(s)) //判栈是否为空printf("栈为空！\n");printf("入栈元素的值为：！\n"); //顺序栈元素入栈scanf("%c",&x);while(x!='\n'){push_seqstack(s,x);scanf("%c",&x);}printf("输出栈的元素:\n");print(s); //输出顺序栈中元素pop_seqstack(s,y); //顺序栈元素出栈printf("出栈的元素为：%c\n",*y); //输出出栈元素printf("出栈后顺序栈中的元素：\n");print(s); //输出出栈后顺序栈中的元素top_seqstack(s,y); //读取顺序栈栈顶元素printf("栈顶的元素值为：%c\n",*y); //输出读出的栈顶元素printf("当前栈中的元素：\n");print(s); //输出当前的顺序栈中的元素}在VS2010上的实现:程序运行后的结果（输入的值为：abcdefghijklmn）：⒉循环队列基本运算程序算法：#include"stdio.h"#include"stdlib.h"#define MAXSIZE 20typedef struct{char data[MAXSIZE]; //队中元素存储空间int rear,front; //队尾和队头指针}sequeue; //顺序队列类型void int_sequeue(sequeue **q) //循环队列初始化（置空队）{*q=(sequeue*)malloc(sizeof(sequeue));//生成循环队列的存储空间(*q)->front=0;//队头和队尾指针相等则队为空(*q)->rear=0;}int empty_sequeue(sequeue *q) //判队空{if(q->front==q->rear)return 1; //队空elsereturn 0; //队不空}void in_sequeue(sequeue *q,char x) //元素入队{if((q->rear+1)%MAXSIZE==q->front)printf("队满！\n"); //队满，入队失败else{q->rear=(q->rear+1)%MAXSIZE; //队尾指针加1q->data[q->rear]=x; //将元素x入队}}void out_sequeue(sequeue *q,char *x) //元素出队{if(q->front==q->rear)printf("队空！\n"); //队空，出队失败else{q->front=(q->front+1)%MAXSIZE; //队头指针加1*x=q->data[q->front];//队头元素出队并由x返回队头元素值}}void print(sequeue *q) //循环队列输出{int i;i=(q->front+1)%MAXSIZE;while(i!=q->rear){printf("%4c",q->data[i]);i=(i+1)%MAXSIZE;}printf("%4c\n",q->data[i]);}void main(){sequeue *q; char x,*y=&x; //出队元素经指针y传给x int_sequeue(&q); //循环队列初始化if(empty_sequeue(q)) //判队空printf("队空！\n");printf("给循环队列输入元素：\n")//给循环队列输入元素scanf("%c",&x);while(x!='\n'){in_sequeue(q,x); //元素入队scanf("%c",&x);}printf("循环队列输出：\n");print(q); //循环队列输出printf("循环队列元素输出：\n");out_sequeue(q,y);//循环队列元素出队printf("输出出队元素为%c\n",*y);//输出出队元素printf("出队后的循环队列的元素：\n");print(q); //输出出队后的循环队列元素}程序在VS2010上的实现：算法的结果为（输入的值为：qwertyuiop）：3.元素逆置算法的实现程序算法为：#include "stdio.h"#include "stdlib.h"typedef struct node{char data;struct node *next;}StackNode; //链栈元素类型void Init_LinkStack(StackNode**s) //链栈初始化{*s=NULL;}int Empty_LinkStack(StackNode*s) //判断链栈是否为空{if(s==NULL)return 1;elsereturn 0;}void Push_LinkStack(StackNode**top,char x) //链栈元素入栈{StackNode *p;p=(StackNode*)malloc(sizeof(StackNode));//生成存放链栈元素的空间p->data=x;p->next=*top;//新生成的栈顶元素*p其后继为原栈顶元素**top*top=p; //栈顶指针*top指向新的栈顶元素*p}void Pop_LinkStack(StackNode**top,char*x) //链栈元素出栈{StackNode*p;if(*top==NULL)printf("栈为空!n"); //栈为空else{*x=(*top)->data;//栈顶元素经指针x传给对应的变量p=*top;*top=(*top)->next;//栈顶指针*top指向出栈后的新栈顶指针free(p);}}void print(StackNode*p) //链栈输出{while(p!=NULL){printf("%c,",p->data);p=p->next;}printf("\n");}void main(){StackNode*s;char x,*y=&x; //出栈元素经指针y传给x Init_LinkStack(&s); //链栈初始化if(Empty_LinkStack(s)) //判断链栈是否为空printf("栈为空!\n");printf("请输入入栈元素:\n"); //链栈元素入栈scanf("%c",&x);while(x!='\n'){Push_LinkStack(&s,x);scanf("%c",&x);}printf("输出的链栈为:\n"); //链栈输出print(s);printf("链栈输出的元素为:\n");Pop_LinkStack(&s,y); //链栈元素出栈printf("出栈的元素为 %c\n",*y); //输出出栈元素printf("输出的链栈:\n");print(s); //链栈输出}在VS2010上的实现：实验结果为：四、实验总结：栈和队列是两种常用的数据结构，栈和队列是操作受限的线性表，栈和队列的数据元素具有单一的前驱和后继的线性关系; 栈和队列又是两种重要的抽象数据类型。
栈和队列练习题答案
栈和队列(答案)1. 一个栈的入栈序列a,b,c,d,e,则栈的不可能的输出序列是__ C __。
A. edcbaB. decbaC. dceabD. abcde2. 若已知一个栈的入栈序列是1,2,3,…,n,其输出序列为p1,p2,p3,…,pn,若p1=n,则pi为__ C __。
A. iB. n=iC. n-i+1D. 不确定3. 栈结构通常采用的两种存储结构是__ A __。
A. 顺序存储结构和链式存储结构散列方式和索引方式链表存储结构和数组线性存储结构和非线性存储结构4. 判定一个顺序栈ST(最多元素为m0)为空的条件是_ B ___。
A. top !=0B. top= =0C. top !=m0D. top= =m0-15. 判定一个顺序栈ST(最多元素为m0)为栈满的条件是__ D __。
A. top!=0B. top= =0C. top!=m0D. top= =m0-16. PUSH 和POP 命令常用于(C)操作。
A 队列B 数组C 栈D 记录7. 向一个栈顶指针为HS的链栈中插入一个s所指结点时,则执行__ C __。
(不带空的头结点)A. HS—>next=s;B. s—>next= HS—>next; HS—>next=s;C. s—>next= HS; HS=s;D. s—>next= HS; HS= HS—>next;8. 从一个栈顶指针为HS的链栈中删除一个结点时,用x 保存被删结点的值,则执行_ B _ __。
(不带空的头结点)A. x=HS; HS= HS—>next;B. x=HS—>data;C. HS= HS—>next; x=HS—>data;D. x=HS—>data; HS= HS—>next;9. 一个队列的数据入队序列是1,2,3,4,则队列出队时的输出序列是__ B __ 。
天大数据结构_实验作业二_栈(顺序栈)+队列(循环队列)
实验作业二：栈（顺序栈）和队列（循环队列）1. 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。
当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。
两个栈均从两端向中间增长。
当向第0号栈插入一个新元素时，使top[0]增1得到新的栈顶位置，当向第1号栈插入一个新元素时，使top[1]减1得到新的栈顶位置。
当top[0]+1 == top[1]时或top[0] == top[1]-1时，栈空间满，此时不能再向任一栈加入新的元素。
试定义这种双栈(Double Stack)结构的类定义，并实现判栈空、判栈满、插入、删除算法。
2. 求fibonacci数列算法，并比较。
（递归+非递归）（非递归方法可查阅其他资料）编写实习报告要求：一、需求分析二、概要设计1.抽象数据类型2.算法三、详细设计程序代码（注释）四、调试分析调试过程中所做的工作，时间复杂度等五、测试结果输入数据和输出数据示例六、说明（如果有）编程语言：C语言或C++语言实习报告提交方式：下次上机前，将实习报告(.doc)和源程序(.cpp)压缩成一个rar 文件，文件名称为学号_班级_姓名_第几次作业。
例如：3010216155_六班_张三_第二次作业.rar。
实习报告作为本课程的平时成绩。
抄袭、雷同，双方均为0分。
第一题：一、需求分析程序要求建立一个共享栈，分配一个存储空间，两个栈分别位于两头。
并实现对两个栈的插入，删除，和判断栈满和栈空。
栈的位置不同，所以要求对不同栈的插入和删除采用不同的算法。
二、概要设计1.抽象数据类型typedef struct {int *base;int *top;int stacksize;}stack;2.算法1.建立栈。
int instack(stack &s,stack &w,int length){s.base=(int *)malloc(length*sizeof(length));w.base=s.base+length;if(!s.base||!w.base) return 0;else{s.top=s.base;w.top=w.base;s.stacksize=length;w.stacksize=length;}return 1;}2.判断栈空。
实验报告——栈和队列的应用
实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。
一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。
所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。
例如，a+b&b+a等等。
题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。
跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。
若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。
现要求写一算法模拟上述舞伴配对问题，并实现。
题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。
请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。
题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。
试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
题目5.利用循环链队列求解约瑟夫环问题。
请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。
选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。
栈和队列习题及答案
栈和队列习题及答案第三章栈和队列⼀、选择题1、⼀个栈的输⼊序列为：a，b，c，d，e，则栈的不可能输出的序列是（）。
A. a,b,c,d,eB. d,e,c,b,aC. d,c,e,a,bD. e,d,c,b,a2、判断⼀个循环队列Q（最多n个元素）为满的条件是（）。
A. Q->rear==Q->frontB. Q->rear==Q->front+1C. Q->front==(Q->rear+1)%nD. Q->front==(Q->rear-1)%n3、设计⼀个判别表达式中括号是否配对的算法，采⽤（）数据结构最佳。
A. 顺序表B. 链表C. 队列D. 栈4、带头结点的单链表head为空的判定条件是（）。
A. head==NULLB. head->next==NULLC. head->next!=NULLD. head!=NULL5、⼀个栈的输⼊序列为：1,2,3,4，则栈的不可能输出的序列是（）。
A. 1243B. 2134C. 1432D. 4312E. 32146、若⽤⼀个⼤⼩为6的数组来实现循环队列，且当rear和front的值分别为0，3。
当从队列中删除⼀个元素，再加⼊两个元素后，rear和front 的值分别为（）。
A. 1和5B. 2和4C. 4和2D. 5和17、队列的插⼊操作是在（）。
A. 队尾B. 队头C. 队列任意位置D. 队头元素后8、循环队列的队头和队尾指针分别为front和rear，则判断循环队列为空的条件是（）。
A. front==rearB. front==0C. rear==0D. front=rear+19、⼀个顺序栈S，其栈顶指针为top，则将元素e⼊栈的操作是（）。
A. *S->top=e;S->top++;B. S->top++;*S->top=e;C. *S->top=eD. S->top=e;10、表达式a*(b+c)-d的后缀表达式是（）。
数据结构第三章栈和队列练习及答案
一、选择题一、选择题1、栈中存取数据的原则（）、栈中存取数据的原则（）A 、先进先出B 、先进后出C 、后进后出D 、随意进出、随意进出2、队列中存取数据的原则（）、队列中存取数据的原则（） A 、先进先出 B 、后进先出 C 、先进后出 D 、随意进出、随意进出3、插入和删除只能在一端进行的线性表，称为（）、插入和删除只能在一端进行的线性表，称为（）A 、队列B 、循环队列C 、栈D 、循环栈、循环栈4、在栈中，出栈操作的时间复杂度为（）、在栈中，出栈操作的时间复杂度为（）A 、O （1）B 、O （log 2n ）C 、O （n ）D 、O （n 2）5、设长度为n 的链队列用单循环链表表示，若只设头指针，则入队操作的时间复杂度为的链队列用单循环链表表示，若只设头指针，则入队操作的时间复杂度为（）（） A 、O （1） B 、O （log 2n ） C 、O （n ） D 、O （n 2）6、设长度为n 的链队列用单循环链表表示，若只设头指针，则出队操作的时间复杂度为的链队列用单循环链表表示，若只设头指针，则出队操作的时间复杂度为（）（） A 、O （1） B 、O （log 2n ） C 、O （n ） D 、O （n 2）7、一个线性表的第一个元素的存储地址是100，每个元素的长度是2，则第5个元素的地址是（）是（） A 、110 B 、108 C 、100 D 、1208、一个栈的入栈序列是a,b,c,d,e ，则栈的不可能的输出序列是（），则栈的不可能的输出序列是（）A 、edcbaB 、decbaC 、dceabD 、abcde9、若已知一个栈的入栈序列是1，2，3，……，n ，其输出序列是p1,p2,p3,……,pn ，若p1=n ，则pi 为（）为（）A 、iB 、n=iC 、n-i+1D 、不确定、不确定10、判断一个栈ST （最多元素m0）为空的条件是（））为空的条件是（）A 、ST->top==0B 、ST->top==-1C 、ST->top!=m0D 、ST->top==m0 11、判断一个栈ST （最多元素m0）为满的条件是（））为满的条件是（）A 、ST->top!=0B 、ST->top==0C 、ST->top!=m0D 、ST->top==m0 12、判断一个循环队列QU （最多元素为m0）为空的条件是（））为空的条件是（） A 、QU.front==QU.rear B 、QU.front!=QU.rearC 、QU.front==(QU.rear+1)%m0D 、QU.front!=(QU.rear+1)%m013、判断一个循环队列QU （最多元素为m0）为满的条件是（））为满的条件是（）A 、QU.front==QU.rearB 、QU.front!=QU.rearC 、QU.front==(QU.rear+1)%m0D 、QU.front!=(QU.rear+1)%m0 14、循环队列用数组存放其元素值A[0，m-1]，已知其头尾指针分别是rear 和front ，则当前队列的元素个数是（）队列的元素个数是（）A 、(rear-front+m)%mB 、rear-front+1C 、rear-front-1D 、rear-front 15、栈和队列的共同特点是（）、栈和队列的共同特点是（）A 、都是先进后出B 、都是先进先出、都是先进先出C 、只允许在端点处插入和删除D 、没有共同点、没有共同点二、填空题二、填空题1、设长度为n 的链队列用单循环链表表示，若只设头指针，则入队和出队操作的时间复杂度分别为（O(N)）和（O(1)）；若又设尾指针，则入队和出队操作的时间复杂度分别为（O(1)）和（O(1)）。
实验二栈与队列操作实验题目
实验二栈与队列操作实验题目实验二栈与队列操作实验目的：(1)理解栈与队列的结构特征和运算特征，以便在实际问题背景下灵活运用。
(2)了解复杂问题的递归算法设计。
本次实验中，下列实验项目选做一。
1、顺序栈的基本操作[问题描述]设计算法，实现顺序栈的各种基本操作[基本要求]（1）初始化栈s。
（2）从键盘输入10个字符以$结束，建立顺序栈。
（3）从键盘输入1个元素，执行入栈操作。
（4）将栈顶元素出栈。
（5）判断栈是否为空。
（6）输出从栈顶到栈底元素。
要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
2、链栈的基本操作[问题描述]设计算法，实现链栈的各种基本操作[基本要求]（1）初始化栈s。
（2）从键盘输入10个字符以$结束，建立带头结点的链栈。
（3）从键盘输入1个元素，执行入栈操作。
（4）完成出栈操作。
（5）判断栈是否为空。
（6）输出从栈顶到栈底元素。
（7）输出链栈的长度。
要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
3、循环队列的基本操作[问题描述]设计算法，实现循环顺序队列的建立、入队、出队等操作。
[基本要求]（1）从键盘输入10个字符以$结束，建立循环队列，并显示结果。
（2）从键盘输入1个元素，执行入队操作，并显示结果。
（3）将队头元素出队，并显示结果。
（4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
4、只用尾指针表示的循环链表队列的综合操作[问题描述]假设以带头结点的的循环链表表示队列，并且只设一个指针指向队尾元素的结点（注意不设头指针），试编写队列初始化、入队、出队函数。
[基本要求及提示]（1）首先定义链表结点类型。
（2）编写带头结点的循环链表的初始化函数，只用尾指针表示。
（3）编写入队函数、出队函数。
（4）在主函数中编写菜单（1.初始化；2.入队；3.出队；4.退出），调用上述功能函数。
数据结构第三章 栈和队列题库(30道)
数据结构第三章栈和队列1、栈的“先进后出”特性是指(——[单选题]A 最后进栈的元素总是最先出栈B 当同时进行进栈和出栈操作时,总是进栈优先C 每当有出栈操作时,总要先进行一次进栈操作D 每次出栈的元素总是最先进栈的元素正确答案：A2、设一个栈的进栈序列是A、B、C、D(即元素A~D依次通过该栈),则借助该栈所得到的输出序列不可能是( )。
——[单选题]A A,B,C,DB D,C,B,AC A,C,D,BD D,A,B,C正确答案：D3、一个栈的进栈序列是a、b、c、d、e,则栈的不可能的输出序列是( )。
——[单选题]A edcbaB decbaC dceabD abcde正确答案：C4、已知一个栈的进栈序列是1,2,3,…,n,其输出序列的第一个元素是i(1≤i≤n)则第j(1≤j≤n)个出栈元素是( )。
——[单选题]A iB n-iC j-i+1D 不确定正确答案：D5、设顺序栈st的栈顶指针top的初始时为-1,栈空间大小为MaxSize,则判定st栈为栈空的条件为( )。
——[单选题]A st.top==-1B st.top!=-1C st.top!=MaxSizeD st.top==MaxSize6、设顺序栈st的栈顶指针top的初始时为-1,栈空间大小为MaxSize,则判定st栈为栈满的条件是。
——[单选题]A st.top!=-1B st.top==-1C st.top!=MaxSize-1D st.top==MaxSize-1正确答案：D7、当用一个数组data[0..n- 1]存放栈中元素时,栈底最好(——[单选题]A 设置在data[0]处B 设置在data[n- 1]处C 设置在data[0]或data[n- 1]处D 设置在data数组的任何位置正确答案：C8、若一个栈用数组data[1..n]存储,初始栈顶指针top为0,则以下元素x进栈的正确操作是(——[单选题]A top++; data[top]=x;B data[top]=x; top++;C Top--; data[top]=x;D data[top]=x; top--;正确答案：A9、若一个栈用数组data[1..n]存储,初始栈顶指针top为n,则以下元素I进栈的正确操作是(——[单选题]A top++; data[top]= x;B data[top]=x; top++ ;C top--; data top]=x;D data[top]=x; top--;正确答案：D10、队列中元素的进出原则是( )。
数据结构上机实验二-栈和链队列
数据结构上机实验二-栈和链队列数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求：可单独完成，也可两人一组。
评分标准：1) 只完成第一或第二题，3分；2）完成一和二题，得5分；3）在2）基础上，可选做三）中的题目。
题目:一)堆栈题（顺序栈）:创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束；(2)在（1）中创建的堆栈中添加一个元素；(3)在（1）中创建的堆栈中删除一个元素；(要求在显示器可见)；二)链队列题目：初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列；(2)在初始化好的链队列中放入数，入队列，完成后要求显示；(3)从队列中出队列，要求显示出来的元素和之后的队列；(4)销毁创建的队列，释放内存；三）应用题（1）编制程序，将输入的十进制数据M 转换为八进制数据M8，将其调试通过。
在此基础上修改程序，实现十进制数据M向任意进制（2-9进制）的转换。
（1分）（2）编制程序，从键盘接收一个字符串(长度最长设为100)，检测其中的括号()，[]，{}匹配情况，若有成对括号则在屏幕输出括号对及其所包含的字符内容。
（2分）（3）假设以Ｉ和Ｏ分别表示入栈和出栈操作。
栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由Ｉ和Ｏ组成的序列，称可以操作的序列为合法序列，否则为非法序列。
编写一个算法，判断所给的序列S1：ＩＯＯＩＩＯＩＯＯ，S２：ＩＯＯＩＯＩＩＯ及S３：ＩＩＩＯＩＯＩＯ，S４：ＩＩＩＯＯＩＯＯ是否合法。
（1分）（4）二项式(a+b)n展开后，其系数构成杨辉三角形，利用队列写出打印杨辉三角形的前n行的程序。
（1分）1111211331……（5）基于堆栈，编写迷宫求解程序。
数据结构(栈和队列)习题与答案
一、单选题1、元素A、B、C、D依次进栈后，栈顶元素是 _______。
A.BB.DC.CD.A正确答案：B2、经过以下运算后， x的值是 _______。
InitStack (s); Push(s, a); Push(s, b); Pop(s, x); GetTop(s,x)A.0B.bC.aD.1正确答案：C3、经过以下栈运算后，StackEmpty(s)的值是 _______。
InitStack (s); Push(s, a); Push(s, b); Pop(s, x); Pop(s,y)A.0B.bC.aD.1正确答案：D4、已知一个栈的进栈序列是ABC，出栈序列为CBA，经过栈的操作是 _______。
A.push, push, push, pop, pop, popB.push,pop,push, push,pop, popC.push, push,pop, pop,push,popD.push,pop,push,pop,push,pop正确答案：A5、若元素a、b、c、d、e、f依次进栈，允许进栈、退栈的操作交替进行，但不允许连续3次退栈工作，则不可能得到的出栈序列是 _______。
A. bcaefdB.afedcbC.cbdaefD.dcebfa正确答案：B6、设一个栈的输入序列为A、B、C、D，则借助一个栈所得的输出序列不可能是_______。
A.DCBAB.DABCC.ACDBD.ABCD正确答案：B7、一个栈的进栈序列是abcde，则栈的不可能的输出序列是 _______。
A.decbaB.abcdeC.dceabD.edcba正确答案：C8、已知一个栈的进栈序列是1，2，3，…n，其输出序列的第一个元素是i（1≤i≤n），则第j（1≤j≤n）个出栈元素是_______。
A.n-iB.j-i+1C.iD.不确定正确答案：D9、已知一个栈的进栈序列是1,2,3，…n，其输出序列是p1,p2,…pn，若p1=n,则pi的值是_______。
栈队列测试[试题]
![栈队列测试[试题]](https://img.taocdn.com/s3/m/9e1511d8a0c7aa00b52acfc789eb172ded6399d3.png)
栈和队列测试题一、判断1.队列中所有的插入操作都发生在表的一端，删除则发生在表的另一端2.栈具有先进先出的特性3.队列为先进后出的结构4.栈用于实现子程序调用5.栈、队列必须用数组来表示6.队列用于操作系统中的作业调度7.线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
8.栈和链表是两种不同的数据结构。
9.栈和队列的存储方式既可是顺序方式，也可是链接方式。
二、单项选择1．循环队列用数组A[maxsize] 表示，下面哪个选项表示该循环队列队满(A) rear==maxsize-1 (B) front==(rear+1)%maxsize(C) rear-front==maxsize (D) rear-front==maxsize-12．元素的入栈序列是a,b,c,d，则栈的不可能的输出序列是(A) dcba (B)abcd (C) dcab (D) cbad3．链表仿真堆栈时，栈空的条件是(A) top<maxsize-1 (B) top==NULL (C) 没有限制 (D) top<04．在用数组queue[maxsize]仿真队列时(temp为int型变量)，假设队列中至少有一个元素，出队列操作应执行以下(A) temp=queue[rear]；rear--； (B) rear++； temp=queue[rear]；(C) temp=queue[front]；front--； (D) front++； temp=queue[front]；5．在用链表仿真堆栈时(假设stack为栈顶指针)，将new指针指向的节点执行入栈操作应执行(A) new->next=stack->next； stack=new； (B) new->next=stack； stack=new；(C)new->next=stack；stack=new->next；(D) stack=new；stack->next=new->next；6．链表仿真堆栈时，栈满的条件是(A) top<maxsize-1 (B) top==NULL (C) 没有限制 (D) top<07．下列哪种数据结构常用于函数调用(A) 堆栈 (B) 队列 (C) 链表 (D) 数组8．编译器中通常以哪种数据结构处理递归程序调用（A）队列（B）数组（C）堆栈（D）记录9．下列哪些数据结构可用来实现堆栈（1）链表（2）数组（3）树（4）图（A）（2），（3）（B）（2），（4）（C）（1），（4）（D）（1），（2）10．下列哪种数据结构常用于系统程序的作业调度（A）栈（B）队列（C）链表（D）数组11．栈和队列的共同点是（A）都是先进后出（B）都是先进先出（C）只允许在端点处插入和删除元素（D）没有共同点12．若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为Ａ．i Ｂ．n=i Ｃ．n-i+1 Ｄ．不确定13．判定一个栈ST（最多元素为m0）为空的条件是Ａ．ST->top<>0 Ｂ．ST->top=0 Ｃ．ST->top<>m0 Ｄ．ST->top=m014．数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素的公式为（Ａ）r－f; （Ｂ）（n＋f－r）% n; （Ｃ）n＋r－f （Ｄ）（n＋r－f）% n15．用单链表表示的链式队列的队头在链表的位置(A)链头(B)链尾(C)链中16．在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓冲区,主机将要输出的数据依次写入该缓冲区,而打印机则从该缓冲区中取出数据打印.该缓冲区应该是一个结构.(A)堆栈(B)队列(C)数组(D)线性表17、判断一个队列QU（最多元素为m0）为空的条件是。
栈与队列习题参考附标准答案
习题三参考答案备注: 红色字体标明的是与书本内容有改动的内容。
一、选择题1.在栈中存取数据的原则是（ B ）。
A．先进先出 B. 先进后出C. 后进后出D. 没有限制2．若将整数1、2、3、4依次进栈，则不可能得到的出栈序列是（ D ）。
A．1234 B. 1324 C. 4321 D. 14233．在链栈中，进行出栈操作时（B ）。
A．需要判断栈是否满 B. 需要判断栈是否为空C. 需要判断栈元素的类型D. 无需对栈作任何差别4．在顺序栈中，若栈顶指针top指向栈顶元素的下一个存储单元，且顺序栈的最大容量是maxSize，则顺序栈的判空条件是（ A ）。
A．top==0 B.top==-1 C. top==maxSize D.top==maxSize-15．在顺序栈中，若栈顶指针top指向栈顶元素的下一个存储单元，且顺序栈的最大容量是maxSize。
则顺序栈的判满的条件是（ C ）。
A．top==0 B.top==-1 C. top==maxSize D.top==maxSize-16．在队列中存取数据元素的原则是（ A ）。
A．先进先出 B. 先进后出C. 后进后出D. 没有限制7．在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front 和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的判空条件是（A ）。
A．front==rear B. front!=rearC. front==rear+1D. front==(rear+1)% maxSize8．在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front 和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的判满条件是（D ）。
A．front==rear B. front!=rearC. front==rear+1D. front==(rear+1)% maxSize9.在循环顺序队列中，假设以少用一个存储单元的方法来区分队列判满和判空的条件，front和rear分别为队首和队尾指针，它们分别指向队首元素和队尾元素的下一个存储单元，队列的最大存储容量为maxSize，则队列的长度是（C ）。
PTA第三章栈和队列练习试题
1-1通过对堆栈S 操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。
输出的序列为：123。
(2分)TF 作者: DS 课程组单位: 浙江大学 1-2在用数组表示的循环队列中，front 值一定小于等于rear 值。
(1分)TF 作者: DS 课程组单位: 浙江大学 1-3若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3, 4, 1, 2, 5}这样的出栈序列。
(2分)TF 作者: 徐镜春单位: 浙江大学 1-4If keys are pushed onto a stack in the order {1, 2, 3, 4, 5}, then it is impossible to obtain the output sequence {3, 4, 1, 2, 5}. (2分)TF 作者: 徐镜春单位: 浙江大学 1-5所谓“循环队列”是指用单向循环链表或者循环数组表示的队列。
(1分)TF 作者: DS 课程组单位: 浙江大学 1-6 An algorithm to check for balancing symbols in an expression uses a stack to store the symbols. (1分)T F 2-1设栈S 和队列Q 的初始状态均为空，元素a 、b 、c 、d 、e 、f 、g 依次进入栈S 。
若每个元素出栈后立即进入队列Q ，且7个元素出队的顺序是b 、d 、c 、f 、e 、a 、g ，则栈S 的容量至少是： (2分)1. 12. 23. 34. 4作者: DS课程组单位: 浙江大学2-2若元素a、b、c、d、e、f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈工作，则不可能得到的出栈序列是？(2分)1. b c a e f d2. c b d a e f3. d c e b f a4. a f e d c b作者: DS课程组单位: 浙江大学2-3设一个栈的输入序列是1、2、3、4、5，则下列序列中，是栈的合法输出序列的是？(2分)1. 3 2 1 5 42. 5 1 2 3 43. 4 5 1 3 24. 4 3 1 2 51.PPPOOOPPOPPOOO2.POPOPOPPOPPOOO3.POPPOOPPOPOOPO4.POPPOOPPOPPOOO作者: DS课程组单位: 浙江大学2-5设一个堆栈的入栈顺序是1、2、3、4、5。
软基上机实验报告-栈和队列(基本题)
一、程序流程说明链栈3-1：1.建立一个空链栈：将链栈的栈顶置为NULL2.进栈：新建一个链栈节点，令这个节点的数据为需要进栈的数据，然后将这个节点指向原栈顶，将栈顶重新定义为这个节点并返回。
3.出栈：首先判断链栈是否为空，如果不为空返回栈顶的下一个节点，然后释放栈顶。
4.建立链栈：建立一个空链栈后调用进栈函数将数据一个一个进栈即可。
循环队列3-2：1.置空队列：使p->front=p->rear=0即可由于循环队列的性质队头或队尾的后移需要这样定义：p->rear=(p->rear+1)%N;p->front=(p->front+1)%N;2.进队列：首先判断队列是否已满，如果没满，将数据插入队尾，然后将队尾向后移动一格。
3.出队列：首先判断队列是否为空，如果不为空，返回队头元素，并将队头向后移一格。
4.aa函数：，调用出队函数把队列q中的元素一一出队，如果是负数直接抛弃；如果是正数，则调用入队函数，插入到q的队尾。
程序代码：链栈3-1：#include<stdio.h>#include<stdlib.h>struct node{int data;//节点信息struct node *next;};//建立一个空链栈node *empty(node *top){top=NULL;return top;}//进栈函数node *pushs(node *top,int x){node *p;p=(node*)malloc(sizeof(node));p->data=x;p->next=top;top=p;return top;}//出栈函数node *pops(node *top){node *p;if(top==NULL){printf("error!\n");return NULL;}else{p=top;top=p->next;free(p);}return top;}//显示函数void show(node *top){printf("the numbers are:\n");while(top!=NULL){printf("%d ",top->data);top=top->next;}}void main(){node *top;top=(node*)malloc(sizeof(node));int x;top=empty(top);printf("insert your number!(use zero as the end)\n");scanf("%d",&x);while(x!=0){top=pushs(top,x);scanf("%d",&x);}show(top);top=pops(top);top=pops(top);printf("\nAfter twice pops\n");show(top);}循环队列3-2：:#include<stdio.h>#include<stdlib.h>#define N 20#define true 1#define false 0typedef struct{int data[N];int front, rear;}node;//进队列函数int enter(node *p,int x){if(((p->rear)+1)%N==p->front)return (false);else{p->data[p->rear]=x;p->rear=(p->rear+1)%N;return (true);}}//出队列函数int out(node *p){int x;if(p->rear==p->front)return (NULL);else{x=p->data[p->front];p->front=(p->front+1)%N;}return x;}//aa函数，其功能为，调用出队函数把队列q中的元素一一出队，//如果是负数直接抛弃；如果是正数，则调用入队函数，插入到q的队尾。