c语言课后题2.52.8答案,第3章课后习题算法设计题（严蔚敏数据结构c语言版第2版）...

3-1 将编号0和1的两个栈存放于一个数组空间V[m]中，栈顶分别处于数组两端。两栈均从两端向中间增长，试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。双栈数据结构的定义如下：

typedef struct

{

int top[2],bot[2];//栈顶和栈底指针

SElemType *V;//栈数组

int m; //栈最大可容纳元素个数

}DblStack;

#include

using namespace std;

#define MAXSIZE 100

typedef struct{

int top[2],bot[2];

int *V;

int m;

}DblStack;

void InitStack(DblStack &s);

void CheckNull(DblStack s);

void CheckFull(DblStack s);

void Push(DblStack &s,int n);

void Pop(DblStack &s,int n);

int main(){

DblStack s;

int n,choice;

InitStack(s);

CheckNull(s);

cout<

cin>>n;

Push(s,n);

cout<

cin>>n;

Pop(s,n);

CheckFull(s);

return 0;

}

//双栈初始化

void InitStack(DblStack &s){

cout<

cin>>s.m;

s.bot[0]=0;

s.bot[1]=s.m-1;

s.top[0]=s.bot[0];

s.top[1]=s.bot[1];

cout<

}

//判断栈空

void CheckNull(DblStack s){

if(s.top[0]==s.bot[0]&&s.top[1]==s.bot[1]){

cout<

}else if(s.top[0]==s.bot[0]&&s.top[1]!=s.bot[1]){

cout<

}else if(s.top[0]!=s.bot[0]&&s.top[1]==s.bot[1]){

cout<

}else{

cout<

}

}

//栈满：两个栈顶相邻

void CheckFull(DblStack s){

if(s.top[1]-s.top[0]==1){

cout<

}else{

cout<

}

}

/*入栈：n为入栈总个数，选择入哪个栈，

如果为1号栈，先输入索引为top[0]值的位置的值，再让top[0]值+1，

如果为2号栈，先输入索引为top[1]值的位置的值，再让top[1]值-1，

接着又判断入哪个栈，重复操作直至入栈总个数达到预定值*/

void Push(DblStack &s,int n){

int e,choice;

for(int i=0;i

cout<

cin>>choice;

if(choice==1){

if(s.top[1]-s.top[0]==1){

cout<

break;

}else{

cout<

cin>>e;

s.V[s.top[0]++]=e;

}

}else{

if(s.top[1]-s.top[0]==1){

cout<

break;

}else{

cout<

cin>>e;

s.V[s.top[1]--]=e;

}

}

}

}

/*出栈：n为出栈总个数，选择出哪个栈，

如果为1号栈，top[0]值先-1,再输出索引为top[0]值的位置的值，

如果为2号栈，top[1]值先+1,再输出索引为top[1]值的位置的值，

接着又判断出哪个栈，重复操作直至出栈总个数达到预定值*/

void Pop(DblStack &s,int n){

int e,choice;

for(int i=0;i

cout<

cin>>choice;

if(choice==1){

if(s.bot[0]==s.top[0]){

cout<

break;

}else{

e=s.V[--s.top[0]];

cout<

}

}else{

if(s.bot[1]==s.top[1]){

cout<

break;

}else{

e=s.V[++s.top[1]];

cout<

}

}

}

}

3-6 假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点(注意：不设头指针)，试编写相应的置空队列、判断队列是否为空、入队和出队等算法

#include

using namespace std;

#define MAXSIZE 100

typedef struct LNode{

int data;

struct LNode *next;

}LNode,*LinkList;

typedef struct{

LinkList rear;

}LinkQueue;

void InitQueue(LinkQueue &q);

void SetNull(LinkQueue &q);

bool CheckNull(LinkQueue q);

void EnQueue(LinkQueue &q,int e);

void DeQueue(LinkQueue &q);

int main(){

LinkQueue q;

InitQueue(q);

EnQueue(q,100);

DeQueue(q);

EnQueue(q,200);

DeQueue(q);

CheckNull(q);

SetNull(q);

CheckNull(q);

return 0;

}

//初始化循环链式队列

void InitQueue(LinkQueue &q){

q.rear=new LNode;

q.rear->next=q.rear;

cout<

}

//置空队列

void SetNull(LinkQueue &q){

LinkList s;

q.rear=q.rear->next;

while(q.rear!=q.rear->next){

s=q.rear->next;

q.rear->next=s->next;

delete s;

}

cout<

}

//判断空队列：尾指针下一个位置指向尾指针本身

bool CheckNull(LinkQueue q){

if(q.rear->next==q.rear){

cout<

return true;

}else{

cout<

return false;

}

}

/*入队：在队尾插入新结点，使新结点的指针指向首节点，尾指针指向新结点*/

void EnQueue(LinkQueue &q,int e){

LinkList p;

p->data=e;

p->next=q.rear->next;

q.rear->next=p;

q.rear=p;

cout<

}

/*出队：在队头删除结点，判断是否是空队列，若为空就返回信息；

若不是且只有一个结点，就让尾指针指向头指针位置，头指针位置的指针指向尾指针；

若不止一个结点，就让头指针位置的指针指向要出队结点的下一个指针位置；

最后释放出队结点的空间*/

void DeQueue(LinkQueue &q){

LinkList p;

int e;

if(CheckNull(q)){

cout<

}else{

p=q.rear->next->next;

e=p->data;

if(p==q.rear){

q.rear=q.rear->next;

q.rear->next=p->next;

}else{

q.rear->next->next=p->next;

}

delete p;

cout<

}

}

3-7 假设以数组Q[m]存放循环队列中的元素，同时设置一个标志tag，以tag=0和tag=1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(dequeue)算法

#include

using namespace std;

#define m 10

typedef struct{

int *base;

int front;

int rear;

int tag;

}SqQueue;

void InitQueue(SqQueue &s);

void EnQueue(SqQueue &s);

void DeQueue(SqQueue &s);

void CheckFullOrNull(SqQueue s);

int main(){

SqQueue s;

InitQueue(s);

EnQueue(s);

DeQueue(s);

return 0;

}

//初始化循环队列

void InitQueue(SqQueue &s){

s.base=new int[m];

s.front=s.rear=0;

s.tag=0;

}

//入队：队尾插入且队尾下标+1，tag=1队列不为空

void EnQueue(SqQueue &s){

int e;

if(s.tag==1&&s.front==s.rear){

cout<

}else{

cout<

cin>>e;

s.base[s.rear]=e;

s.rear=(s.rear+1)%m;

s.tag=1;

}

CheckFullOrNull(s);

}

//出队:队头删除，且队头下标+1，当队尾等于队头下标tag=0队列为空

void DeQueue(SqQueue &s){

int e;

if(s.tag==0&&s.front==s.rear){

cout<

}else{

e=s.base[s.front];

s.front=(s.front+1)%m;

cout<

if(s.rear==s.front){

s.tag=0;

}

}

CheckFullOrNull(s);

}

void CheckFullOrNull(SqQueue s){

if(s.tag==0){

cout<

}else{

cout<

}

}

3-8 如果允许在循环队列的两端都可以进行插入和删除操作。要求：(1)写出循环队列类型定义(2)写出“从队尾删除”和“从队头插入”的算法

#include

using namespace std;

#define m 10

typedef struct{

int *base;

int front;

int rear;

}SqQueue;

//从队头入队

void EnQueue(SqQueue &s){

int e;

if(s.front==(s.rear+1)%m){

cout<

}else{

cout<

cin>>e;

s.base[s.front]=e;

s.front=(s.front-1+m)%m;

}

}

//从队尾出队

void DeQueue(SqQueue &s){

int e;

if(s.front==s.rear){

cout<

}else{

e=s.base[s.rear];

s.rear=(s.rear-1+m)%m;

cout<

}

}

//初始化循环队列

void InitQueue(SqQueue &s){

s.base=new int[m];

s.front=s.rear=0;

}

void InitQueue(SqQueue &s);

void EnQueue(SqQueue &s);

void DeQueue(SqQueue &s);

int main(){

SqQueue s;

InitQueue(s);

EnQueue(s);

DeQueue(s);

return 0;

}