数据结构实验报告（二）

实验二 栈、队列

（1）实验内容
1．采用链式存储实现栈的初始化、入栈、出栈操作。
2．采用顺序存储实现栈的初始化、入栈、出栈操作。
3．采用链式存储实现队列的初始化、入队、出队操作。
4．采用顺序存储实现循环队列的初始化、入队、出队操作。
5．在主函数中设计一个简单的菜单，分别测试上述算法。
*6．综合训练:1)利用栈实现表达式求值算法。
2)利用栈实现迷宫求解。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
#define OVERFLOW -2
using namespace std;
//顺序栈
typedef int Elemtype;
typedef struct {
Elemtype elem[MAXSIZE];
int top;
}SeqStack;
void initSeqStack(SeqStack &s){
s.top=-1;
}
int stackEmpty(SeqStack &s){
if (s.top==-1)
return 1;
return 0;//或者返回 表达式的真值return s.top==-1;
}
int push(SeqStack &s,Elemtype e){
if (s.top>=MAXSIZE-1)
return 0;
else {
s.top++;
s.elem[s.top]=e;
return 1;
}
}
int pop(SeqStack &s,Elemtype &e){
if (s.top==-1)
return 0;
else {
e=s.elem[s.top];
s.top--;
return 1;
}
}
int gettop(SeqStack &s,Elemtype &e){
if (s.top==-1)
return 0;
else {
e=s.elem[s.top];
return 1;
}
}
void display(SeqStack &s){
for (int i=0;i<=s.top;i++){
cout<<s.elem[i]<<" ";
}
cout<<endl;
}

//链栈
typedef struct node {
Elemtype data;
struct node *next;
}node,*linkstack;
void initLinkstack(linkstack &top){
top=NULL;//无头节点的链栈
}
int linkstackEmpty(linkstack &top){
return top==NULL;
}
int linkstackPush(linkstack &top,Elemtype e){
linkstack p=(linkstack )malloc (sizeof(node));
if (!p) exit(OVERFLOW);
p->data=e;
p->next=top;
top=p;
return 1;
}
int linkstackPop(linkstack &top,Elemtype &e){
e=top->data;
linkstack p=top;
top=top->next;
free(p);
return 1;
}
void getTop(linkstack &top,Elemtype &E){
E=top->data;
}
void displaylinkstack(linkstack &top){
linkstack p=top;
while (p){
printf ("%d ",p->data);
p=p->next;
}
printf ("
");
}
//顺序循环队列
typedef int Elemtype;
typedef struct{
Elemtype data[MAXSIZE];
int rear,front;
}Seqqueue;
void initSeqqueue(Seqqueue &q){
q.rear=q.front=-1;
}
int emptySeqqueue(Seqqueue &q){
return q.rear==q.front;
}
int enSeqqueue(Seqqueue &q,Elemtype e){
    //先判断是否队满
    if ((q.rear+1)%MAXSIZE==q.front){
    printf ("full!
");
    return 0;
    }
    q.rear=(q.rear+1)%MAXSIZE;
    q.data[q.rear]=e;
    return 1;
}
int deSeqqueue(Seqqueue &q,Elemtype &e){
if (emptySeqqueue(q)){
printf ("null!
");
return 0;
}
q.front=(q.front+1)%MAXSIZE;
e=q.data[q.front];
return 1;
}
Elemtype getFront(Seqqueue &q){
if (emptySeqqueue(q)){
printf ("null!
");
}
else {
Elemtype e;
q.front=(q.front+1)%MAXSIZE;
e=q.data[q.front];
return e;
}
}
int length(Seqqueue &q){
return (q.rear-q.front+MAXSIZE)%MAXSIZE;
}
void display(Seqqueue &q){
if (emptySeqqueue(q)){
printf ("null!
");
}
else {
int i=(1+q.front)%MAXSIZE;
for (int j=0;j<length(q);j++){
printf ("%d ",q.data[i]);
i++;
}
printf ("
");
}
}


//链队列
typedef int Elemtype;
typedef struct qnode {
Elemtype data;
struct qnode *next;
}qnode,*Queueptr;
typedef struct {
Queueptr front ;
Queueptr rear;
}linkQueue;
int  initQueue(linkQueue &q){
Queueptr lq=(Queueptr)malloc(sizeof(qnode));
if (!lq) exit(OVERFLOW);
lq->next=NULL;
q.front=q.rear=lq;
}
int isempty(linkQueue q){
return q.front==q.rear;
}
int enterQueue(linkQueue &q,Elemtype e){
Queueptr p=(Queueptr)malloc(sizeof(qnode));
if (!p) exit(OVERFLOW);
p->data=e;
p->next=q.rear->next;
q.rear->next=p;
q.rear=p;
return 1;
}
int deQueue(linkQueue &q,Elemtype &e){
    //出队依旧要判空，入队不需要判满了
    if (q.rear==q.front){
    printf("null
");
    return 0;
    }
Queueptr p=q.front->next;
e=p->data;
q.front->next=p->next;
//这里要特别注意如果链表中唯一的元素要出队，尾指针必须要重新指向头结点，不然丢失该指针了
if (q.front->next==NULL){//或者q.rear==p;
q.rear=q.front;
}
free(p);
return 1;
}
void display(linkQueue &q){
Queueptr p=q.front->next;
while (p){
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;
}
int main()
{
    SeqStack s;
    Elemtype e;
    linkstack top;
    Seqqueue q;
    linkQueue Q;

    cout<<"---------------------------------------------------"<<endl;
    cout<<"1.采用顺序存储实现栈的初始化、入栈、出栈操作"<<endl;
    cout<<"2.采用链式存储实现栈的初始化、入栈、出栈操作"<<endl;
    cout<<"3.采用顺序存储实现队列的初始化、入队、出队操作"<<endl;
    cout<<"4.采用链式存储实现循环队列的初始化、入队、出队操作"<<endl;
    cout<<"---------------------------------------------------"<<endl;
    int x,i;
    cout<<"请输入您的选择！"<<endl;
    while (cin>>x){
    switch(x){
    case 1:{
    initSeqStack(s);
    cout<<"初始化顺序栈成功！"<<endl;
    cout<<"请输入压栈的内容！"<<endl;
    cin>>i;
    while (i!=-999){
    push(s,i);
    cin>>i;
    }
    cout<<"压栈成功！显示栈内数字！"<<endl;
    display(s);
    cout<<"获取栈顶元素！"<<endl;
    gettop(s,e);
    printf ("%d
",e);
    cout<<"弹栈！"<<endl;
    while (s.top>0){
    pop(s,e);
    cout<<"弹出元素："<<e<<" ";
    }
    cout<<endl;
    cout<<"显示栈内数字！"<<endl;
    display(s);
    break;
    }
    case 2:
    initLinkstack(top);
    cout<<"初始化链栈成功！"<<endl;
    cout<<"请输入压栈的内容！"<<endl;
    cin>>i;
    while (i!=-999){
    linkstackPush(top,i);
    cin>>i;
    }

    cout<<"压栈成功！显示栈内数字！"<<endl;
    displaylinkstack(top);
    cout<<"获取栈顶元素！"<<endl;
    getTop(top,e);
    printf ("%d
",e);
    while (top){
    linkstackPop(top,e);
    cout<<"弹出元素："<<e<<" ";
    }
    cout<<endl;
    cout<<"显示栈内数字！"<<endl;
    displaylinkstack(top);
    break;
    case 3:
    initSeqqueue(q);
    cout<<"初始化顺序队列成功！"<<endl;
    cout<<"请输入进队的内容！"<<endl;
    cin>>i;
    while (i!=-999){
    enSeqqueue(q,i);
    cin>>i;
    }
    cout<<"进队成功！显示队内数字！"<<endl;
    display(q);
    cout<<"返回队头元素！"<<endl;
    e=getFront(q);
    cout<<e<<endl;
    while (!emptySeqqueue(q)){
    deSeqqueue(q,e);
    cout<<"出队元素"<<e<<" ";
    }
    cout<<endl;
    cout<<"显示队内数字"<<endl;
    display(q);
    break;
    case 4:
    initQueue(Q);
    cout<<"初始化链队列成功！"<<endl;
    cout<<"请输入进队的内容！"<<endl;
    cin>>i;
    while (i!=-999){
    enterQueue(Q,i);
    cin>>i;
    }
    cout<<"进队成功！显示队内数字！"<<endl;
    display(Q);

    while (!isempty(Q)){
    deQueue(Q,e);
    cout<<"出队元素"<<e<<" ";
    }
    cout<<endl;
    cout<<"显示队内数字"<<endl;
    display(Q);
    break;
    }
    cout<<"请输入您的选择！"<<endl;
    }

    return 0;
}