数据结构第三章课后答案
数据结构(C++版)课后答案_(王红梅)第3章_特殊线性表
⑻ 设数组 S[n]作为两个栈 S1 和 S2 的存储空间，对任何一个栈只有当 S[n]全满时才不能进行进栈操作。为这两个栈 分配空间的最佳方案是（ ）。 A S1 的栈底位置为 0，S2 的栈底位置为 n-1 B S1 的栈底位置为 0，S2 的栈底位置为 n/2 C S1 的栈底位置为 0，S2 的栈底位置为 n D S1 的栈底位置为 0，S2 的栈底位置为 1 【解答】A ⑼ 设有两个串 p 和 q，求 q 在 p 中首次出现的位置的运算称作（ ）。 A 连接 B 模式匹配 C 求子串 D 求串长 【解答】B
⑷ 设计一个判别表达式中左右括号是否配对的算法，采用（ ）数据结构最佳 A 顺序表 B 栈 C 队列 D 链表 【解答】B
⑸ 在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印缓冲区，该缓冲区应该是一个（ ）结构。 A 栈 B 队列 C 数组 D 线性表 【解答】B
⑹ 一个队列的入队顺序是 1，2，3，4，则队列的输出顺序是（ ）。 A 4321 B 1234 C 1432 D 3241 【解答】B
5. 举例说明顺序队列的“假溢出”现象。 【解答】假设有一个顺序队列，如图 3-6 所示，队尾指针 rear=4，队头指针 front=1，如果再有元素入队，就会产生“上 溢”，此时的“上溢”又称为“假溢出”，因为队列并不是真的溢出了，存储队列的数组中还有 2 个存储单元空闲，其下标 分别为 0 和 1。
⑷ 对于采用顺序存储结构的串 S，编写一个函数删除其值等于 ch 的所有字符。 【解答】从后向前删除值为 ch 的所有元素，这样所有移动的元素中没有值为 ch 的元素，能减少移动元素的次数，提 高算法的效率。算法如下：
数据结构第三章习题答案解析
第三章习题1.按图3.1(b)所示铁道（两侧铁道均为单向行驶道）进行车厢调度，回答：⑴如进站的车厢序列为123，则可能得到的出站车厢序列是什么？⑵如进站的车厢序列为123456，能否得到435612和135426的出站序列，并说明原因。
（即写出以“S”表示进栈、以“X”表示出栈的栈操作序列）。
2.设队列中有A、B、C、D、E这5个元素，其中队首元素为A。
如果对这个队列重复执行下列4步操作：（1）输出队首元素；（2）把队首元素值插入到队尾；（3）删除队首元素；（4）再次删除队首元素。
直到队列成为空队列为止，得到输出序列：（1）A、C、E、C、C （2） A、C、E（3） A、C、E、C、C、C （4） A、C、E、C3.给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？4.按照四则运算加、减、乘、除和幂运算（↑）优先关系的惯例，画出对下列算术表达式求值时操作数栈和运算符栈的变化过程：A－B＊Ｃ／Ｄ＋Ｅ↑Ｆ5.试写一个算法，判断依次读入的一个以@为结束符的字母序列，是否为形如‘序列1& 序列2’模式的字符序列。
其中序列1和序列2中都不含字符’&’，且序列2是序列1的逆序列。
例如，‘a+b&b+a’是属该模式的字符序列，而‘１+３&３－１’则不是。
6.假设表达式由单字母变量和双目四则运算算符构成。
试写一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰式。
7.假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的队列初始化、入队列和出队列的算法。
8.要求循环队列不损失一个空间全部都能得到利用, 设置一个标志域tag , 以tag为0或1来区分头尾指针相同时的队列状态的空与满，请编写与此结构相应的入队与出队算法。
9.简述以下算法的功能（其中栈和队列的元素类型均为int）：（1）void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);}for(i=1; i<=n; i++)Push(&S, A[i]);}（2）void proc_2(Stack S, int e) { Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}（3）void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q，d)}}实习题1．回文判断。
数据结构(C语言版)第三章习题解答
第三章习题解答1.分别写出对链栈的入栈和出栈操作的算法。
链栈的结点类型定义如下：Typedef struct stacknode {SElemtype data;struct stacknode *next;}stacknode, *linkstack;入栈操作：Status push( linkstack &S, SElemtype e){ p=(linkstack)malloc(sizeof(stacknode));If (!p) return ERROR;p->data=e;p->next=S;S=p;return OK;}出栈操作：Status pop(linkstack &S, SElemtype &e){ if (!S) return ERROR;p=s;s=p->next;free(p);return OK;}P24/3.15假设以顺序存储结构实现一个双向栈，即在一维数组的存储空间中存在着两个栈，它们的栈底分别设在数组的两个端点。
试编写实现这个双向栈tws的三个操作：初始化inistack(tws),入栈push(tws,i,x)和出栈pop(tws,i)的算法，其中i为0或1，用以分别指示设在数组两端的两个栈，并讨论按过程（正/误状态变量可设为变参）或函数设计这些操作算法各有什么优缺点。
双栈的结构类型定义如下：typedef struct{Elemtype *base[2];Elemtype *top[2];}BDStacktype; //双向栈类型栈的初始化操作：status Init_Stack(BDStacktype &tws,int m)//初始化一个大小为m的双向栈tws{ tws.base[0]=(Elemtype*)malloc(m*sizeof(Elemtype));tws.base[1]=tws.base[0]+m-1;tws.top[0]=tws.base[0];tws.top[1]=tws.base[1];return OK;}入栈操作：Status push(BDStacktype &tws,int i,Elemtype x) // x入栈,i=0表示低端栈,i=1表示高端栈{ if (tws.top[0]>tws.top[1]) return OVERFLOW;//注意此时的栈满条件if (i==0) *tws.top[0]++=x;elseif (i==1) *tws.top[1]--=x;else return ERROR;return OK;}出栈操作：Status pop(BDStacktype &tws, int i, Elemtype &x) // x出栈,i=0表示低端栈,i=1表示高端栈{ if (i==0){ if (tws.top[0]==tws.base[0]) return OVERFLOW;x=*--tws.top[0];}else if (i==1){ if (tws.top[1]==tws.base[1]) return OVERFLOW;x=*++tws.top[1];}else return ERROR;return OK;}P24/3.18试写一个判别表达式中开、闭括号是否配对出现的算法。
数据结构(第二版)习题答案第3章
3.1 选择题第3章线性表的链式存储（1）两个有序线性表分别具有n个元素与m个元素且n≤m，现将其归并成一个有序表，其最少的比较次数是（ A ）。
A．n B．m C．n− 1D．m + n（2）非空的循环单链表head 的尾结点（由p 所指向）满足（ C ）。
A．p->next==NULL B．p==NULL C．p->next==head D．p==head （3）在带头结点的单链表中查找x应选择的程序体是（ C ）。
A．node *p=head->next; while (p && p->info!=x) p=p->next;if (p->info==x) return p else return NULL;B．node *p=head; while (p&& p->info!=x) p=p->next; return p;C．node *p=head->next; while (p&&p->info!=x) p=p->next; return p;D．node *p=head; while (p->info!=x) p=p->next ; return p;（4）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ D ）。
A．必须是连续的C．一定是不连续的B．部分地址必须是连续的D．连续不连续都可以（5）在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间复杂度是（ B ）。
A．O(1) B．O(n) C．O(n2) D．O(n log2n)（6）用不带头结点的单链表存储队列时，其队头指针指向队头结点，其队尾指针指向队尾结点，则在进行删除操作时（ D ）。
A．仅修改队头指针C．队头、队尾指针都要修改B．仅修改队尾指针D．队头,队尾指针都可能要修改（7）若从键盘输入n个元素，则建立一个有序单向链表的时间复杂度为（ B ）。
数据结构第三章树答案
数据结构第三章树答案数据结构与算法上机作业第三章树一、选择题1、在一棵树中，如果结点A有3个兄弟，B是A的双亲，则B的度为 DA. 1B. 2C. 3D. 42、深度为h的完全二叉树至少有 D 个结点，至多有 B 个结点A. 2hB. 2h-1C. 2h+1D. 2h-13、具有n个结点的满二叉树有 C 个叶结点。
A. n/2B. (n-1)/2C. (n+1)/2D. n/2+14、一棵具有25个叶结点的完全二叉树最多有 C 个结点。
A. 48B. 49C. 50D. 515、已知二叉树的先根遍历序列是ABCDEF，中根遍历序列是CBAEDF，则后根遍历序列是 A 。
A. CBEFDAB. FEDCBAC. CBEDFAD. 不定6、具有10个叶结点的二叉树中有 B 个度为2的结点。
A. 8B. 9C. 10D. 117、一棵非空二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足 C 。
A. 所有非叶结点均无左孩子B. 所有非叶结点均无右孩子C. 只有一个叶子结点D. A和B同时成立8、在线索二叉树中，t所指结点没有左子树的充要条件是 B 。
A. t->left=NULLB. t->ltag=TRUEC. t->ltag=TRUE且t->left=NULLD. 以上都不对9、n个结点的线索二叉树上含有的线索数为 C 。
A. 2nB. n-1C. n+1D. n10、二叉树按照某种顺序线索化后，任一结点都有指向其前驱和后继的线索，这种说法 B 。
A. 正确B. 错误C. 不确定D. 都有可能11、具有n(n>1)个结点的完全二叉树中，结点i(2i>n)的左孩子结点是 D 。
A. 2iB. 2i+1C. 2i-1D. 不存在12、具有64个结点的完全二叉树的深度为 C 。
A. 5B. 6C.7D. 813、将一颗有100个结点的完全二叉树从上到下、从左到右一次对结点进行编号，根结点的编号为1，则编号为45的结点的右孩子的编号为 D 。
数据结构课后习题答案第三章
第三章栈和队列(参考答案)// 从数据结构角度看，栈和队列是操作受限的线性结构，其顺序存储结构// 和链式存储结构的定义与线性表相同，请参考教材，这里不再重复。
3.1 1 2 3 4 2 1 3 4 3 2 1 4 4 3 2 11 2 4 3 2 1 4 3 3 2 4 11 32 4 23 14 3 4 2 11 3 42 234 11 4 32 2 43 1设入栈序列元素数为n，则可能的出栈序列数为C2n n=(1/n+1)*(2n!/(n!)2)3.2 证明：由j<k和p j<p k说明p j在p k之前出栈，即在k未进栈之前p j已出栈，之后k进栈，然后p k出栈；由j<k和p j>p k说明p j在p k之后出栈，即p j被p k压在下面，后进先出。
由以上两条，不可能存在i<j<k使p j<p k<p i。
也就是说，若有1，2，3顺序入栈，不可能有3，1，2的出栈序列。
3.3 void sympthy(linklist *head, stack *s)//判断长为n的字符串是否中心对称{ int i=1; linklist *p=head->next;while (i<=n/2) // 前一半字符进栈{ push(s,p->data); p=p->next; }if (n % 2 !==0) p=p->next;// 奇数个结点时跳过中心结点while (p && p->data==pop(s)) p=p->next;if (p==null) printf(“链表中心对称”)；else printf(“链表不是中心对称”)；} // 算法结束3.4int match()//从键盘读入算术表达式，本算法判断圆括号是否正确配对（init s;//初始化栈sscanf(“%c”,&ch);while (ch!=’#’) //’#’是表达式输入结束符号switch (ch){ case ’(’: push(s,ch); break;case ’)’: if (empty(s)) {printf(“括号不配对”); exit(0);}pop(s);}if (!empty(s)) printf(“括号不配对”);else printf(“括号配对”);} // 算法结束3.5typedef struct // 两栈共享一向量空间{ ElemType v[m]; // 栈可用空间0—m-1int top[2] // 栈顶指针}twostack;int push(twostack *s,int i, ElemType x)// 两栈共享向量空间,i是0或1，表示两个栈，x是进栈元素，// 本算法是入栈操作{ if (abs(s->top[0] - s->top[1])==1) return(0);// 栈满else {switch (i){case 0: s->v[++(s->top)]=x; break;case 1: s->v[--(s->top)]=x; break;default: printf(“栈编号输入错误”); return(0);}return(1); // 入栈成功}} // 算法结束ElemType pop(twostack *s,int i)// 两栈共享向量空间,i是0或1，表示两个栈，本算法是退栈操作{ ElemType x;if (i!=0 && i!=1) return(0);// 栈编号错误else {switch (i){case 0: if(s->top[0]==-1) return(0);//栈空else x=s->v[s->top--];break;case 1: if(s->top[1]==m) return(0);//栈空else x=s->v[s->top++]; break;default: printf(“栈编号输入错误”);return(0);}return(x); // 退栈成功}} // 算法结束ElemType top (twostack *s,int i)// 两栈共享向量空间,i是0或1，表示两个栈，本算法是取栈顶元素操作{ ElemType x;switch (i){case 0: if(s->top[0]==-1) return(0);//栈空else x=s->v[s->top]; break;case 1: if(s->top[1]==m) return(0);//栈空else x=s->v[s->top]; break;default: printf(“栈编号输入错误”);return(0);}return(x); // 取栈顶元素成功} // 算法结束3．6void Ackerman(int m,int n)// Ackerman 函数的递归算法{ if (m==0) return(n+1);else if (m!=0 && n==0) return(Ackerman(m-1,1);else return(Ackerman(m-1,Ackerman(m,n-1))} // 算法结束3．7(1) linklist *init(linklist *q)// q是以带头结点的循环链表表示的队列的尾指针，本算法将队列置空{ q=(linklist *)malloc(sizeof(linklist));//申请空间，不判断空间溢出q->next=q;return (q);} // 算法结束(2) linklist *enqueue(linklist *q，ElemType x)// q是以带头结点的循环链表表示的队列的尾指针，本算法将元素x入队{ s=(linklist *)malloc(sizeof(linklist));//申请空间，不判断空间溢出s->next=q->next; // 将元素结点s入队列q->next=s;q=s; // 修改队尾指针return (q);} // 算法结束(3) linklist *delqueue(linklist *q)//q是以带头结点的循环链表表示的队列的尾指针，这是出队算法{ if (q==q->next) return (null); // 判断队列是否为空else {linklist *s=q->next->next; // s指向出队元素if (s==q) q=q->next; // 若队列中只一个元素，置空队列else q->next->next=s->next;// 修改队头元素指针free (s); // 释放出队结点}return (q);} // 算法结束。
数据结构教程第三版第三章课后习题答案
scanf("%d",&a); if (a>0) { if ((qu->rear+1)%QueueSize==qu->front)
printf(" 队列满,不能入队\n"); else { qu->rear=(qu->rear+1)%QueueSize; //入队
qu->data[qu->rear]=a; } } else if (a<0) { if (qu->rear==qu->front)
QT[x]=s;
之后 //让 QT[x]仍指向尾结点
}
}
void Create(QNode *QH[],QNode *QT[]) //根据用户输入创建队列
{ int n,x,i;
printf("n:");
scanf("%d",&n);
for (i=0;i<n;i++)
{ do
{ printf("输入第%d 个数:",i+1);
{ tail->next=QH[i];
tail=QT[i];
}
}
printf("\n 输出所有元素:");
while (head!=NULL)
{ printf("%d ",head->data);
head=head->next;
}
printf("\n");
}
void main()
{ int i; QNode *QH[MAXQNode],*QT[MAXQNode]; //各队列的队头 QH 和队尾指针 QT for
第3章 数据结构 答案
第3章数据结构一、选择题1. 图形结构是数据元素之间存在一种____B_____。
A 一对多关系B 多对多关系C 多对一关系D 一对一关系2.算法分析的目的是___C_____。
A 找出数据结构的合理性B 研究算法中的输入和输出的关系C 分析算法的效率以求改进D 分析算法的易懂性和文档性3.算法的时间复杂度与___A____ 有关。
A 问题规模B 计算机硬件性能C 程序设计语言的类型或版本D 算法设计者的水平4.有下面的算法段：for (i=0; i<n; i++)k++;其时间复杂度为 B 。
A．O(1) B．O(n) C．O(log2n) D．O(n2)5.计算机算法必须具备输入、输出和___C____。
A、计算方法B、排序方法C、解决问题的有限运算步骤D、程序设计法6.____B___是数据的基本单位。
A、数据结构B、数据元素C、数据项D、数据类型7.下面，对非空线性表特点的论述，___C____是正确的。
A．所有结点有且只有一个直接前驱B．所有结点有且只有一个直接后继C．每个结点至多只有一个直接前驱，至多只有一个直接后继D．结点间是按照1对多的邻接关系来维系其逻辑关系的8.在顺序表中，只要知道____D____，就可以在相同的时间内求出任一结点的存储地址。
A、开始结点B、终端结点C、向量大小D、基地址和结点大小9.在非空线性表中，有且只有一个直接前驱和一个直接后继的结点是__C____。
A、开始结点B、终端结点C、内部结点D、所有结点10.顺序表中逻辑上相邻的结点的物理位置为_____A___。
A、一定相邻B、不必相邻C、按某种规律排列D、不要求11.一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是____B___。
A 110B 108C 100D 12012.链表不具有的特点是____A___。
A、可以随机访问任何一个元素B、插入和删除元素不需要移动元素C、不必事先估计存储空间D、所需的存储空间和链表长度无关13.数据结构反映了数据元素之间的结构关系。
数据结构与算法(C语言篇)第3章 习题答案[3页]
![数据结构与算法(C语言篇)第3章 习题答案[3页]](https://img.taocdn.com/s3/m/13d25cd2760bf78a6529647d27284b73f342364e.png)
习题答案1.填空题（1）栈（2）队列（3）后进先出（4）先进先出2.选择题（1）A （2）C （3）D （4）D、A （5）C （6）B3.思考题（1）栈是一种运算受限制的线性表，其只允许在表的一端进行插入和删除操作，俗称堆栈。
允许进行操作的一端称为“栈顶”，而另一个固定端称为“栈底”，栈中的数据在进行入栈和出栈时，遵循后进先出的原则。
队列同样是一种运算受限制的线性表，是限制在两端进行插入和删除操作的线性表。
允许进行插入操作的一端称为“队尾”，而允许进行删除操作的一端称为“队头”，队列中的数据在进行入队和出队时，遵循先进先出的原则。
4.编程题（1）//入栈//参数1为栈顶指针（头结点指针），参数2为插入的数据int linkstack_push(linkstack_t *s, datatype_t value){linkstack_t *temp;//使用malloc函数为新插入的结点申请内存空间temp = (linkstack_t *)malloc(sizeof(linkstack_t));//为新插入的结点赋值temp->data = value;//用头插法实现入栈temp->next = s->next;s->next = temp;return 0;}//判断栈是否为空int linkstack_empty(linkstack_t *s){return s->next == NULL ? 1 : 0; //判断下一个结点是否为空}//出栈datatype_t linkstack_pop(linkstack_t *s){linkstack_t *temp;datatype_t value;if(linkstack_empty(s)){printf("linkstack empty\n");return -1;}//头删法表示出栈，后入先出temp = s->next;s->next = temp->next;//保存出栈的数据value = temp->data;//释放出栈的结点的内存空间free(temp);temp = NULL;//返回出栈的数据return value;}（2）//入队//参数1为存放队列头尾结点指针的结构体地址，参数2为新入队的数据int linkqueue_enter(linkqueue_t *lq, datatype_t value){ linknode_t *temp;//使用malloc函数为头结点申请内存空间temp = (linknode_t *)malloc(sizeof(linknode_t));//采用尾插法的设计思想temp->data = value; //为新结点赋值temp->next = NULL; //将新结点的指针指向NULLlq->rear->next = temp; //入队，将新结点加入队列尾部lq->rear = temp; //移动rear指针，指向新加入的结点 return 0;}//判断队列是否为空int linkqueue_empty(linkqueue_t *lq){//当front与rear指向同一个结点时，判断队列为空return lq->front == lq->rear ? 1 : 0;}//出队//从头结点开始删除，包括头结点datatype_t linkqueue_out(linkqueue_t *lq){linknode_t *temp;datatype_t value;if(linkqueue_empty(lq)){printf("linkqueue empty\n");return -1;}temp = lq->front; //获取删除结点//移动front指针到下一个结点lq->front = lq->front->next;//获取下一个结点的数据value = lq->front->data;free(temp); //释放需要删除结点的内存空间 temp = NULL; //避免出现野指针//返回结点数据return value;}。
数据结构第三章参考答案
习题31．填空题（1）栈的进出原则是（___________），队列的进出原则是（___________）。
答案：后进先出（LIFO）先进先出（FIFO）（2）设32位计算机系统中，空栈S存储int型数据，栈顶指针为1024H。
经过操作序列push(1)，push(2)，pop，push(5)，push(7)，pop，push(6)之后，栈顶元素为（___________），栈底元素为（___________），栈的高度为（___________），输出序列是（___________），栈顶指针为（___________）H。
答案：6 1 3 2,7 1030（3）两栈共享存储空间，其数组大小为100，数组下标从0开始。
top1和top2分别为栈1和栈2的栈顶元素下标，则栈1为空的条件为（___________），栈2为空的条件为（___________），栈1或栈2满的条件为（___________）。
答案：top1==-1 top2==100 top1+1==top2（4）一个队列的入队顺序是1234，则队列的输出顺序是（___________）。
答案：1234（5）设循环队列数组大小为100，队头指针为front，队尾指针为rear；约定front指向队头元素的前一个位置，该位置永远不存放数据。
则入队操作时，修改rear=（___________），出队操作修改front=（___________），队空的判别条件为（___________），队满的判别条件为（___________）。
若front=20，rear=60，则队列长度为（___________），若front=60,rear=20，则队列长度为（___________）。
答案：(rear+1)%100 (front+1)%100 rear==front (rear+1)%100=front 40 60（6）朴素模式匹配算法中，每个串的起始下标均为1，变量i=100，j=10，分别表示主串和模式串当前比较的字符元素下标，若本次比较两字符不同，则i回溯为（___________），j 回溯为（___________）。
数据结构(第二版)习题答案第3章教程文件
数据结构(第二版)习题答案第3章3.1 选择题第3章线性表的链式存储（1）两个有序线性表分别具有n个元素与m个元素且n≤m，现将其归并成一个有序表，其最少的比较次数是（ A ）。
A．n B．m C．n− 1D．m + n（2）非空的循环单链表 head 的尾结点（由 p 所指向）满足（ C ）。
A．p->next==NULL B．p==NULL C．p->next==head D．p==head （3）在带头结点的单链表中查找x应选择的程序体是（ C ）。
A．node *p=head->next; while (p && p->info!=x) p=p->next;if (p->info==x) return p else return NULL;B．node *p=head; while (p&& p->info!=x) p=p->next; return p;C．node *p=head->next; while (p&&p->info!=x) p=p->next; return p;D．node *p=head; while (p->info!=x) p=p->next ; return p;（4）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ D ）。
A．必须是连续的C．一定是不连续的B．部分地址必须是连续的D．连续不连续都可以（5）在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间复杂度是（ B ）。
A．O(1) B．O(n) C．O(n2) D．O(n log2n)（6）用不带头结点的单链表存储队列时，其队头指针指向队头结点，其队尾指针指向队尾结点，则在进行删除操作时（ D ）。
A．仅修改队头指针C．队头、队尾指针都要修改B．仅修改队尾指针D．队头,队尾指针都可能要修改（7）若从键盘输入n个元素，则建立一个有序单向链表的时间复杂度为（ B ）。
《数据结构》第三章习题参考答案 殷人昆版
《数据结构》第三章习题参考答案殷人昆版，《数据结构》第三章习题参考答案一、判断题（在正确说法的题后括号中打“√”，错误说法的题后括号中打“×”）1、栈和队列都是线性表，只是在插入和删除时受到了一些限制。
( √ )2、循环队列也存在空间溢出问题。
( √ )3、任何一个递归过程都可以转换成非递归过程。
( √ )4、消除递归不一定需要使用栈。
( √ )5、有n个数顺序（依次）进栈，出栈序列有Cn种，Cn=(1/（n+1）)*（2n）!/((n!)*(n!))。
（√ ）6、循环队列方式能很好地解决队列的假溢出现象。
（√ ）二、单项选择题1、1．设有一个顺序栈S，元素P1，P2，P3，P4，P5，P6依次进栈，得到的出栈顺序P2，P3，P4，P6，P5，P1，则顺序栈的容量至少为（ B ）。
A．2 B．3 C．4D．无法确定2．一个队列的输出序列是1，2，3，4，则队列的入队序列是（ A ）。
A．1，2，3，4 B．1，4，3，2 C．4，3，2，1 D．不确定3、对于一个循环队列（最大元素个数为maxSize）进行入队操作时，对队列指针的修改正确的语句是（ C ）。
A．rear = rear + 1 B．front = front + 1C．rear = (rear + 1)% maxSize D．front = (front + 1)% maxSize4、假设以数组A[m]存放循环队列的元素,其头尾指针分别为front和rear，则当前队列中的元素个数为（ A ）。
A．(rear-front+m)%m B．rear-front+1 C．(front-rear+m)%m D．(rear-front)%m5、表达式a*(b+c)-d的后缀表达式是( B )。
A．abcd*+- 表达式[a-（c*d+b）] B. abc+*d- C. abc*+d- 表达式b*c+a-d D. -+*abcd6、若用一个大小为6的数组来实现循环队列，且当前rear和front的值分别为0和3，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为多少？( B )A. 1和 5B. 2和4C. 4和2D. 5和17、设abcdef以所给的次序进栈，若在进栈操作时，允许退栈操作，则下面得不到的序列为（ D ）。
数据结构第3单元课后练习答案
//构造函数 template <class T> LinkedStack<T>::LinkedStack() { top=NULL; } //析构函数 template <class T> LinkedStack<T>::~LinkedStack() { Node<T> *q; while (top) { q=top->link; delete top; top=q; } }
答：2）和3）不能。对2）中的E，B，D而言，E最先 出栈则表明，此时B和D均在栈中，由于，B先于D进 栈，所以应有D先出栈。同理3）也不能。 (1)能。 push,pop,push,pop,push,pop,push,pop,push,pop (4)能。 push,push,push,push,push,pop,pop,pop,pop,pop
第三单元 栈与队列
链式堆栈的单链表 √ ）。 栈和队列都是线性表，只是在插入和删除时受到了一些限制（× ）。
设A、B、C、D、E五个元素依次进栈(进栈后可立即出栈)， 问能否得到下列序列。若能得到，则给出相应的push和 pop序列；若不能，则说明理由。 1) A,B,C,D,E 2) A,C,E,B,D 3) C,A,B,D,E 4) E,D,C,B,A
//解法三 不用栈，也不用数组，只用一个计数器top bool match(char a[],int n) { int top=-1; for (int i=0;i<n;i++) if (a[i]=='(') top++; else if (a[i]==')') if (top>-1) top--; //继续检查 else return true; //不匹配 if (top>-1) return true; //不匹配 return false; //匹配 }
数据结构（第二版）习题答案第3章
第3章线性表的链式存储3.1选择题（1）两个有序线性表分别具有 n个元素与m个元素且n≤m，现将其归并成一个有序表，其最少的比较次数是（ A）。
A．n B．m C．n . 1D．m + n（2）非空的循环单链表head的尾结点（由 p所指向）满足（C）。
A．p->next==NULL B．p==NULL C．p->next==hea d D．p==hea d（3）在带头结点的单链表中查找x应选择的程序体是（C ）。
A．no de *p=head->nex t; wh ile (p &&p->in fo!=x) p=p->nex t;i f (p->info==x)retur n p e lse r eturn NULL;B．node*p=he ad; w hile(p&&p->in fo!=x) p=p->nex t; re turnp;C．node *p=h ead->next; whil e (p&&p->i nfo!=x) p=p->ne xt; r eturn p; D．nod e *p=head; whil e (p->info!=x)p=p->next; ret urn p;（4）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（D ）。
A．必须是连续的B．部分地址必须是连续的C．一定是不连续的D．连续不连续都可以（5）在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间复杂度是（ B ）。
数据结构课后答案第3章
第 3 章特殊线性表——栈、队列和串2005-07-14第 3 章特殊线性表——栈、队列和串课后习题讲解1. 填空⑴设有一个空栈，栈顶指针为1000H，现有输入序列为1、2、3、4、5，经过push，push，pop，push，pop，push，push后，输出序列是（），栈顶指针为（）。
【解答】23，1003H⑵栈通常采用的两种存储结构是（）；其判定栈空的条件分别是（），判定栈满的条件分别是（）。
【解答】顺序存储结构和链接存储结构（或顺序栈和链栈），栈顶指针top= -1和top=NULL，栈顶指针top等于数组的长度和内存无可用空间⑶（）可作为实现递归函数调用的一种数据结构。
【解答】栈【分析】递归函数的调用和返回正好符合后进先出性。
⑷表达式a*(b+c)-d的后缀表达式是（）。
【解答】abc+*d-【分析】将中缀表达式变为后缀表达式有一个技巧：将操作数依次写下来，再将算符插在它的两个操作数的后面。
⑸栈和队列是两种特殊的线性表，栈的操作特性是（），队列的操作特性是（），栈和队列的主要区别在于（）。
【解答】后进先出，先进先出，对插入和删除操作限定的位置不同⑹循环队列的引入是为了克服（）。
【解答】假溢出⑺数组Q[n]用来表示一个循环队列，front为队头元素的前一个位置，rear为队尾元素的位置，计算队列中元素个数的公式为（）。
【解答】（rear-front+n）% n【分析】也可以是（rear-front）% n，但rear-front的结果可能是负整数，而对一个负整数求模，其结果在不同的编译器环境下可能会有所不同。
⑻用循环链表表示的队列长度为n，若只设头指针，则出队和入队的时间复杂度分别是（）和（）。
【解答】Ｏ(1)，Ｏ(n)【分析】在带头指针的循环链表中，出队即是删除开始结点，这只需修改相应指针；入队即是在终端结点的后面插入一个结点，这需要从头指针开始查找终端结点的地址。
⑼串是一种特殊的线性表，其特殊性体现在（）。
数据结构第三章习题答案
第三章习题1、按图3、1(b)所示铁道(两侧铁道均为单向行驶道)进行车厢调度,回答:⑴如进站得车厢序列为123,则可能得到得出站车厢序列就是什么？⑵如进站得车厢序列为123456,能否得到435612与135426得出站序列,并说明原因。
(即写出以“S”表示进栈、以“X”表示出栈得栈操作序列)。
2、设队列中有A、B、C、D、E这5个元素,其中队首元素为A。
如果对这个队列重复执行下列4步操作:(1)输出队首元素;(2)把队首元素值插入到队尾;(3)删除队首元素;(4)再次删除队首元素。
直到队列成为空队列为止,得到输出序列:(1)A、C、E、C、C (2) A、C、E(3) A、C、E、C、C、C (4) A、C、E、C3、给出栈得两种存储结构形式名称,在这两种栈得存储结构中如何判别栈空与栈满？4、按照四则运算加、减、乘、除与幂运算(↑)优先关系得惯例,画出对下列算术表达式求值时操作数栈与运算符栈得变化过程:A－B＊Ｃ／Ｄ＋Ｅ↑Ｆ5、试写一个算法,判断依次读入得一个以为结束符得字母序列,就是否为形如‘序列1& 序列2’模式得字符序列。
其中序列1与序列2中都不含字符’&’,且序列2就是序列1得逆序列。
例如,‘a+b&b+a’就是属该模式得字符序列,而‘１+３&３－１’则不就是。
6、假设表达式由单字母变量与双目四则运算算符构成。
试写一个算法,将一个通常书写形式且书写正确得表达式转换为逆波兰式。
7、假设以带头结点得循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应得队列初始化、入队列与出队列得算法。
8、要求循环队列不损失一个空间全部都能得到利用, 设置一个标志域tag , 以tag为0或1来区分头尾指针相同时得队列状态得空与满,请编写与此结构相应得入队与出队算法。
9、简述以下算法得功能(其中栈与队列得元素类型均为int):(1)void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);} for(i=1; i<=n; i++)Push(&S, A[i]);}(2)void proc_2(Stack S, int e){ Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}(3)void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q,d)}}实习题1.回文判断。
数据结构 第3章答案(已核)
3.5习题一、名词解释（1）栈栈是限制在表的一端进行插入和删除操作的线性表。
允许插入、删除的这一端称为栈顶，另一个固定端称为栈底。
栈的顺序结构：利用顺序存储方式实现的栈称为顺序栈。
栈的链式结构：用链式存储结构实现的栈称为链栈。
（2）队队是一种“先进先出” (FIFO---First In First Out)的数据结构，即插入操作在表一端进行，而删除操作在表的另一端进行，这种数据结构称为队列。
把允许插入的一端称为队尾(rear)，把允许删除的一端称为队头(front)。
队的顺序结构：顺序存储的队称为顺序队。
队的链式结构：采用链式存储结构的队称为链队。
二、判断题（1）栈和队列都是特殊的线性表。
( √ )（2）栈和队列都将插入和删除操作限制在表的端点处进行。
(√ )（3）只允许在表的一端进行插入和删除操作的线性表称为栈。
(√)（4）没有元素的栈称为空栈，空栈用不着栈顶指针。
( × )（5）只要栈不空，就能任意删除栈的元素。
(× )（6）栈允许删除的一端称为栈顶，而栈底元素是不能删除的。
(× )（7）对采用链式存储结构的栈进行操作不必判断溢出。
(√ )（8）元素进出队列一定满足“先进先出”的规律。
(√ )（9）链队列不存在溢出问题。
(√ )（10）在链队列中删除一个元素是在链表的最前端进行的。
(√ )三、单项选择题（1）栈和队列的共同之处在于它们具有相同的( A )。
A．逻辑特性 B．物理特性 C．运算方法 D．元素类型（2）栈和队列都是特殊的线性表，其特殊性在于( C )。
A．它们具有一般线性表所没有的逻辑特性B．它们的存储结构比较特殊C．对它们的使用方法做了限制D．它们比一般线性表更简单（3）若5个元素的出栈序列为1，2，3，4，5，则进栈序列可能是( )。
A．2，4，3，1，5 B．2，3，1，5，4C．3，1，4，2，5 D．3，1，2，5，4（4）某队列初始为空，若它的输入序列为a，b，c，d，它的输出序列应为( )。
数据结构第三章习题及解答
数据结构第三章习题及解答Chap3一选择题1. 对于栈操作数据的原则是（B）。
A. 先进先出B. 后进先出C. 后进后出D. 不分顺序2. 在作进栈运算时,应先判别栈是否( B ),在作退栈运算时应先判别栈是否( A )。
当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为( B )。
A. 空B. 满C. 上溢D. 下溢③: A. n-1 B. n C. n+1 D. n/23. 一个栈的输入序列为123…n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（B）。
A. 不确定B. n-i+1C. iD. n-i4. 有六个元素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 34 15 65. 设栈的输入序列是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，6. 设一个栈的输入序列是1，2，3，4，5,则下列序列中，是栈的合法输出序列的是（D）。
A. 5 1 2 3 4B. 4 5 1 3 2C. 4 3 1 2 5D.3 2 1 5 47. 设有三个元素X，Y，Z顺序进栈（进的过程中允许出栈），下列得不到的出栈排列是( C)。
A．XYZ B. YZX C. ZXYD. ZYX8. 执行完下列语句段后，i值为：（B）int f(int x){ return ((x>0) ? x* f(x-1):2);}int i ;i =f(f(1));A．2 B. 4 C. 8 D. 无限递归9. 用不带头结点的单链表存储队列时,其队头指针指向队头结点,其队尾指针指向队尾结点，则在进行删除操作时( D )。
A．仅修改队头指针 B. 仅修改队尾指针C. 队头、队尾指针都要修改D. 队头,队尾指针都可能要修改10. 递归过程或函数调用时，处理参数及返回地址，要用一种称为（ C ）的数据结构。
数据结构习题答案第三章
void DSqStack <ElemType>::Pop(int i) {//i 的取值为 0 或 1
if (i == 0) top[0]--;
else top[1]++;
}//Pop
5. (1). A, C, D (2). 从左到右读序列，任何时候累计 I 的个数都应大于等于 O 的个数。 (3). bool islegal(char *a) {
newbase[k + 10] = base[k];
delete[] base;
base = newbase;
size += 10;
top[1] += 10;
}
if (i == 0)
base[++top[0]] = e;
else
base[--top[1]] = e;
}//Push
//出栈，弹出栈顶元素。先决条件是栈非空。 template <class ElemType>
ElemType & Top(int i) const;
void Push(const ElemType &e,int i);
void Pop(int i);
private:
//双向栈类的数据成员
ElemType *base; //基地址指针
int top[2];
//栈顶指针
int size;
//向量空间大小
//void Leabharlann lear();//bool Empty() const;
//int Length() const;
//ElemType & GetHead() const;
数据结构课后习题及解析第三章
第三章习题1.按图3.1(b)所示铁道（两侧铁道均为单向行驶道）进行车厢调度，回答：⑴如进站的车厢序列为123，则可能得到的出站车厢序列是什么？⑵如进站的车厢序列为123456，能否得到435612和135426的出站序列，并说明原因。
（即写出以“S”表示进栈、以“X”表示出栈的栈操作序列）。
2.设队列中有A、B、C、D、E这5个元素，其中队首元素为A。
如果对这个队列重复执行下列4步操作：（1）输出队首元素；（2）把队首元素值插入到队尾；（3）删除队首元素；（4）再次删除队首元素。
直到队列成为空队列为止，得到输出序列：（1）A、C、E、C、C （2） A、C、E（3） A、C、E、C、C、C （4） A、C、E、C3.给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？4.按照四则运算加、减、乘、除和幂运算（↑）优先关系的惯例，画出对下列算术表达式求值时操作数栈和运算符栈的变化过程：A－B＊Ｃ／Ｄ＋Ｅ↑Ｆ5.试写一个算法，判断依次读入的一个以@为结束符的字母序列，是否为形如‘序列1& 序列2’模式的字符序列。
其中序列1和序列2中都不含字符’&’，且序列2是序列1的逆序列。
例如，‘a+b&b+a’是属该模式的字符序列，而‘１+３&３－１’则不是。
6.假设表达式由单字母变量和双目四则运算算符构成。
试写一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰式。
7.假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的队列初始化、入队列和出队列的算法。
8.要求循环队列不损失一个空间全部都能得到利用, 设置一个标志域tag , 以tag为0或1来区分头尾指针相同时的队列状态的空与满，请编写与此结构相应的入队与出队算法。
9.简述以下算法的功能（其中栈和队列的元素类型均为int）：（1）void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);} for(i=1; i<=n; i++)Push(&S, A[i]);}（2）void proc_2(Stack S, int e) { Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}（3）void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q，d)}}实习题1．回文判断。