数据结构与算法分析（C++语言版）_张琨版第三章栈和队列课后习题答案

最新推荐文章于 2023-07-14 23:40:38 发布

赵卓不凡

最新推荐文章于 2023-07-14 23:40:38 发布

阅读量849

点赞数

分类专栏：计算机考研文章标签：课后习题答案数据结构与算法分析

本文链接：https://blog.csdn.net/sgzqc/article/details/119052568

版权

计算机考研专栏收录该内容

9 篇文章 13 订阅

订阅专栏

一、选择题

D A 2.A 3.C 4.D 5.C 6. B 7.C 8.C 9. C 10.A

二、填空题

1.栈顶 2.链栈 3. 空 4.不可能 5. O(1) 6. A D
7.设所创建的链栈为s 则s=NULL 8. 链栈头链栈头
9.设所创建的链队指针为p 则p->next=NULL
10． LiQueue * qu=( LiQueue *)malloc(sizeof(LiQueue)); //申请空间
qu->front=qu->rear=NULL; //队头队尾指针置为NULL

三、判断题

× 当栈中只有一个元素时，这个元素也称栈底元素，它可以删除
× 顺序栈是指用顺序存储结构实现的栈，栈中的元素不一定是有序的
× 比如进栈序列是123 出栈序列可以是132
√ 当栈中只有一个元素时就是这种情况
× 可以进行任意多次的进栈、出栈操作，但栈中最多只有m个元素
× 可以进行任意多次的进栈、出栈操作
√
× 只要栈不满就可以进行进栈操作，只要栈不空就可以进行出栈操作，并不规定进栈、出栈操作的次序
× 空栈是指栈中没有元素，但一定有栈顶元素
√ 因为无论出队还是入队，都要进行求余运算，将队首指针和队尾指针转化为有效的顺序队下标值，另外，循环顺序队中的元素可以平行移动，所以本叙述是正确的

四、简答题

可能的次序为CDBAE、CDEBA、CDBEA
高级语言变量名的定义规则是：以字母开头的字母数字串。入栈次序为123PA,以A最先出栈的序列为AP321,以P最先出栈的序列为P321A，P32A1，P3A21，PA321。所以可以作为高级语言的变量名的序列为AP321，P321A，P32A1，P3A21，PA321。
1）能得到输出顺序为325641的序列，其操作序列为：AAADDAADADDD
2) 不能得到输出顺序为154623的序列；执行ADAAAADDAD,得到输出序列1546后，栈中元素从栈顶到栈底为32，不能让2先出栈，所以得不到输出序列154632。
证明过程如下图所示：
证明过程如下图所示：

五、计算题

设置一个栈st，扫描表达式exp，遇到‘(’、‘[’、‘{’，则将其入栈，遇到‘)’，若栈顶是‘(’，则继续处理，否则以不匹配返回0；遇到‘]’，若栈顶是‘[’，则继续处理，否则以不匹配返回0；遇到‘}’，若栈顶是‘{’，则继续处理，否则以不匹配返回0；在exp扫描完毕后，若栈不空，则以不配对返回0；否则以括号配对返回1.对应算法如下：

int match(char exp[],int n)
{
	char st[MaxSize];
	int top=-1;
	int i=0,tag=1;
	while(i<n && tag==1)
	{
		if(exp[i]=='(' || exp[i]=='[' ||exp[i]=='{')
		{
			top++;
			st[top]=exp[i];			
		}
		if(exp[i]==')')
		{
			if(st[top]=='(')
				top--;
			else
				tag=0;
		}
		if(exp[i]==']')
		{
			if(st[top]=='[')
				top--;
			else
				tag=0;
		}
		if(exp[i]=='}')
		{
			if(st[top]=='{')
				top--;
			else
				tag=0;
		}
		i++;
	}
	if(top>=0)
		tag=0;

	return tag;
}

过程如下：

Void process(int m, int a[],int curp)
为了简单，栈运算只设计了基本的处理过程。完整程序如下

#include<stdio.h>
#define MaxSize 10
struct stacknode
{
	int data[MaxSize];
	int top;
}st;

int total = 4;
char str[] = "1234";
int sum = 0;

void initstack()
{
	st.top = -1;
}
void push(int n)
{
	st.top++;
	st.data[st.top] = n;
}
int pop()
{
	int temp;
	temp = st.data[st.top];
	st.top--;
	return temp;
}
bool empty()
{
	if (st.top == -1)
		return true;
	return false;
}
void process(int m, int a[], int curp)
{
	int x, i;
	if (m > total && empty())
	{
		printf(" ");
		for (i = 0; i < curp; i++)
			printf("%c ", str[a[i] - 1]);
		printf("\n");
		sum++;
	}
	if (m <= total)
	{
		push(m);
		process(m + 1, a, curp);
		pop();
	}
	if (!empty())
	{
		x = pop();
		a[curp] = x;
		curp++;
		process(m, a, curp);
		push(x);
	}
}
void main()
{
	int a[MaxSize];
	initstack();
	printf("所有出栈序列：\n");
	process(1, a, 0);
	printf("出栈序列个数%d\n", sum);
}

该程序的执行结果如下：
在这里插入图片描述
3. 解析过程如下：

typedef struct{
	ElemType S[MaxSize];
	int top1,top2;
}StackType;

void InitStack1(StackType &st)
{
	st.top1=-1;
	st.top2=MaxSize;
}
int StackEmpty1(StackType st,int i)//i==1 栈1   i==2 栈2
{
	if(i==1)//i==1
		return (st.top==-1);
	else//i==2
		return (st.top==MaxSize);
}
int Push1(StackType &st,int i,ElemType x)
{
	if (st.top1==st.top2-1)
	{
		return 0;
	}
	if(i==1)//栈1
	{
		st.top1++;
		st.S[st.top1]=x;
	}
	else//栈2
	{
		st.top2--;
		st.S[st.top2]=x;
	}
	else//参数错误
		return 0;
	return 1；
}
int Pop1（StackType &st, int i,ElemType &x）
{
	if(i==1)
	{
		if(st.top1==-1)
			return 0;
		else
		{
			x=st.S[st.top1];
			st.top1--;
		}
	}
	else if(i==2)
	{
		if(st.top2==MaxSize)
			return 0;
		else
		{
			x=st.S[st.top2];
			st.top2++;
		}
	}
	else
		return 0;
	return 1;
}

4.假定采用顺序栈结构，先退栈st中所有元素，利用一个临时栈tmps存放从st栈中退栈的元素，最后的一个元素即为所求，然后将临时栈tmps中的元素逐一出栈并进栈到st中，这样恢复st栈中原来的元素。相关代码如下：

int GetBottom(SqStack st,ElemType &x)
{
	ElemType e;
	SqStack tmpst;
	initstack(tmpst);
	if (StackEmpty(st))
	{
		return 0;
	}
	while(!StackEmpty(st))
	{
		Pop(st,x);
		Push(tmpst,x);
	}
	while(!StackEmpty(tmpst))
	{
		Pop(tmpst,x);
		Push(st,e);
	}
	return 1;
}

5.代码如下

#include <stdio.h>
#include <malloc.h>
typedef struct qnode
{
    int data;
    struct qnode *next;
} QNode;            /*链队结点类型*/

typedef struct
{
    QNode *front,*rear;
} QuType;           /*链队类型*/

void SeeDoctor()
{
    int sel,flag=1,find,no;
    QuType *qu;
    QNode *p;
    qu=(QuType *)malloc(sizeof(QuType));    /*创建空队*/
    qu->front=qu->rear=NULL;
    while (flag==1)                             /*循环执行*/
    {
        printf("1:排队 2:就诊 3:查看排队 4.不再排队,余下依次就诊 5:下班  请选择:");
        scanf("%d",&sel);
        switch(sel)
        {
        case 1:
            printf("  >>输入病历号:");
            do
            {
                scanf("%d",&no);
                find=0;
                p=qu->front;
                while (p!=NULL && !find)
                {
                    if (p->data==no)
                        find=1;
                    else
                        p=p->next;
                }
                if (find)
                    printf("  >>输入的病历号重复,重新输入:");
            }
            while (find==1);
            p=(QNode *)malloc(sizeof(QNode));   /*创建结点*/
            p->data=no;
            p->next=NULL;
            if (qu->rear==NULL)                 /*第一个病人排队*/
            {
                qu->front=qu->rear=p;
            }
            else
            {
                qu->rear->next=p;
                qu->rear=p; /*将*p结点入队*/
            }
            break;
        case 2:
            if (qu->front==NULL)                /*队空*/
                printf("  >>没有排队的病人!\n");
            else                                /*队不空*/
            {
                p=qu->front;
                printf("  >>病人%d就诊\n",p->data);
                if (qu->rear==p)            /*只有一个病人排队的情况*/
                {
                    qu->front=qu->rear=NULL;
                }
                else
                    qu->front=p->next;
                free(p);
            }
            break;
        case 3:
            if (qu->front==NULL)            /*队空*/
                printf("  >>没有排列的病人!\n");
            else                            /*队不空*/
            {
                p=qu->front;
                printf("  >>排队病人:");
                while (p!=NULL)
                {
                    printf("%d ",p->data);
                    p=p->next;
                }
                printf("\n");
            }
            break;
        case 4:
            if (qu->front==NULL)            /*队空*/
                printf("  >>没有排列的病人!\n");
            else                            /*队不空*/
            {
                p=qu->front;
                printf("  >>病人按以下顺序就诊:");
                while (p!=NULL)
                {
                    printf("%d ",p->data);
                    p=p->next;
                }
                printf("\n");
            }
            flag=0;                         /*退出*/
            break;
        case 5:
            if (qu->front!=NULL)            /*队不空*/
                printf("  >>请排队的病人明天就医!\n");
            flag=0;                     /*退出*/
            break;
        }
    }
    p=qu->front;  //销毁队列
    while (p!=NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
}

int main()
{
    SeeDoctor();
    return 0;
}

运行结果如下：

在这里插入图片描述

六、说明

本人已毕业多年，读研时撰写了一份《数据结构与算法分析（C++语言版）_张琨版课后习题答案》，每年依旧有大量考研的学弟学妹们来找这份答案，现将其公布在blog上，仅供学术交流，上述解答如有问题，可私信沟通。

赵卓不凡

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构与算法分析（C++语言版）_张琨版第三章栈和队列课后习题答案

一、选择题D A 2.A 3.C 4.D 5.C 6. B 7.C 8.C 9. C 10.A二、填空题1.栈顶 2.链栈 3. 空 4.不可能 5. O(1) 6. A D7.设所创建的链栈为s 则s=NULL 8. 链栈头链栈头9.设所创建的链队指针为p 则p->next=NULL10． LiQueue * qu=( LiQueue *)malloc(sizeof(LiQueue)); //申请空间qu->front=qu->rea
复制链接

扫一扫