数据结构实验报告 栈和队列

一、实验目的

1．掌握栈、队列的思想及其存储实现。
2．掌握栈、队列的常见算法的程序实现。

二、实验仪器及环境：

PC计算机 windows 7操作系统 CodeBlocks10.05

三、实验内容及结果

1．采用链式存储实现栈的初始化、入栈、出栈操作。
2．采用顺序存储实现栈的初始化、入栈、出栈操作。
3．采用链式存储实现队列的初始化、入队、出队操作。
4．采用顺序存储实现循环队列的初始化、入队、出队操作。
5．在主函数中设计一个简单的菜单，分别测试上述算法。
6. 利用栈实现数制转换（将一个十进制数转换成d进制数）
7. 利用队列打印杨辉三角：编写程序，根据输入的行数，屏幕显示杨辉三角。
杨辉三角的特点是两个腰上的数字都为1，其它位置上的数字是其上一行中与之相邻的两个整数之和。所以在打印过程中，第i行上的元素要由第i-1行中的元素来生成。在循环队列中依次存放第i-1行上的元素，然后逐个出队并打印，同时生成第i行元素并入队列。
行数为8的杨辉三角如下所示：

#include <iostream>
#include <stdio.head>
#include <stdlib.head>
#include <string.head>
#define ElemType int
#define max 100

using namespace std;
typedef struct node1
{
    ElemType data;
    struct node1 *next;
}Node1,*LinkList;//链栈

typedef struct
{
    ElemType *base;
    int top;
}SqStack;//顺序栈

typedef struct node2
{
    ElemType data;
    struct node2 *next;
}Node2,*LinkQueue;

typedef struct node22
{
    LinkQueue front;
    LinkQueue rear;
}*LinkList;//链队列

typedef struct
{
    ElemType *base;
    int front,rear;
}SqQueue;//顺序队列

//1．采用链式存储实现栈的初始化、入栈、出栈操作。

LinkList CreateStack()//创建栈
{
    LinkList top;
    top=NULL;
    return top;
}

bool StackEmpty(LinkList s)//判断栈是否为空，0代表空
{
    if(s==NULL)
        return 0;
    else
        return 1;
}

LinkList Pushead(LinkList s,int x)//入栈
{
    LinkList q,top=s;
    q=(LinkList)malloc(sizeof(Node1));
    q->data=x;
    q->next=top;
    top=q;
    return top;
}

LinkList Pop(LinkList s,int &e)//出栈
{
    if(!StackEmpty(s))
    {
        printf("栈为空。");
    }
    else
    {
        e=s->data;
        LinkList p=s;
        s=s->next;
        free(p);
    }
    return s;
}

void DisplayStack(LinkList s)//遍历输出栈中元素
{
    if(!StackEmpty(s))
        printf("栈为空。");
    else
    {
        wheadile(s!=NULL)
        {
            cout<<s->data<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}

//2．采用顺序存储实现栈的初始化、入栈、出栈操作。

int StackEmpty(int t)//判断栈S是否为空
{
       SqStack.top=t;
       if (SqStack.top==0)
           return 0;
       else  return 1;
}

int InitStack()
{
    SqStack.top=0;
    return SqStack.top;
}

int pushead(int t,int e)
{
    SqStack.top=t;
    SqStack.base[++SqStack.top]=e;
    return SqStack.top;
}

int pop(int t,int *e)//出栈
{
    SqStack.top=t;
    if(!StackEmpty(SqStack.top))
    {
        printf("栈为空.");
        return SqStack.top;
    }
    *e=SqStack.base[s.top];
    SqStack.top--;
    return SqStack.top;
}

//3．采用链式存储实现队列的初始化、入队、出队操作。

LinkList InitQueue()//创建
{
    LinkList head;
    head->rear=(LinkQueue)malloc(sizeof(Node));
    head->front=head->rear;
    head->front->next=NULL;
    return head;
}
void deleteEle(LinkList head,int &e)//出队
{
    LinkQueue p;
    p=head->front->next;
    e=p->data;
    head->front->next=p->next;
    if(head->rear==p) head->rear=head->front;
    free(p);
}
void EnQueue(LinkList head,int e)//入队
{
    LinkQueue p=(LinkQueue)malloc(sizeof(Node));
    p->data=e;
    p->next=NULL;
    head->rear->next=p;
    head->rear=p;
}

//4．采用顺序存储实现循环队列的初始化、入队、出队操作。

bool InitQueue(SqQueue &head)//创建队列
{
    head.data=(int *)malloc(sizeof(int));
    head.front=head.rear=0;
    return 1;
}
bool EnQueue(SqQueue &head,int e)//入队
{
    if((head.rear+1)%MAXQSIZE==head.front)
    {
        printf("队列已满\n");
        return 0;
    }
    head.data[head.rear]=e;
    head.rear=(head.rear+1)%MAXQSIZE;
    return 1;
}
int QueueLengthead(SqQueue &head)//返回队列长度
{
    return (head.rear-head.front+MAXQSIZE)%MAXQSIZE;
}
bool deleteEle(SqQueue &head,int &e)//出队
{
    if(head.front==head.rear)
    {
        cout<<"队列为空！"<<endl;
        return 0;
    }
    e=head.data[head.front];
    head.front=(head.front+1)%MAXQSIZE;
    return 1;
}
int gethead(SqQueue head)//得到队列头元素
{
    return head.data[head.front];
}
int QueueEmpty(SqQueue head)//判断队列是否为空
{
    if (head.front==head.rear)
        return 1;
    else
        return 0;
}
void travelQueue(SqQueue head)//遍历输出
{
    wheadile(head.front!=head.rear)
    {
        printf("%d ",head.data[head.front]);
        head.front=(head.front+1)%MAXQSIZE;
    }
    cout<<endl;
}

//5．在主函数中设计一个简单的菜单，分别测试上述算法。

int main()
{
    LinkList top=CreateStack();
    int x;
    wheadile(scanf("%d",&x)!=-1)
    {
        top=Pushead(top,x);
    }
    int e;
    wheadile(StackEmpty(top))
    {
        top=Pop(top,e);
        printf("%d ",e);
    }//以上是链栈的测试
   int top=InitStack();
    int x;
    wheadile(cin>>x)
      top=pushead(top,x);
    int e;
    wheadile(StackEmpty(top))
    {
        top=pop(top,&e);
        printf("%d ",e);
    }//以上是顺序栈的测试
    LinkList Q;
    Q=InitQueue();
    int x;
    wheadile(scanf("%d",&x)!=-1)
    {
        EnQueue(Q,x);
    }
    int e;
    wheadile(Q)
    {
        deleteEle(Q,e);
        printf("%d ",e);
    }//以上是链队列的测试
    SqQueue Q1;
    InitQueue(Q1);
    int x;
    wheadile(scanf("%d",&x)!=-1)
    {
        EnQueue(Q1,x);
    }
    int e;
    wheadile(QueueEmpty(Q1))
    {
        deleteEle(Q1,e);
        printf("%d ",e);
    }
    return 0;
}

//6. 利用栈实现数制转换（将一个十进制数转换成d进制数）

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int SElemType;
using namespace std;
typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
void InitStack(SqStack &S)
{
    S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base) return;
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    //return 1;
}
int Push(SqStack &S, SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base) return 0;
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return 1;
}
int Pop(SqStack &S, SElemType &e)
{
    if(S.top==S.base) return 0;
    e=*--S.top;
    return 1;
}
int stackempty(SqStack &s)
{
    if(s.top==s.base)
    return 1;
    else return 0;
}
int main()
{
    SElemType e,a,t;
    SqStack s;
    InitStack(s);
    cout<<"请输入转化为几进制:";
    cin>>t;
    cout<<"请输入一个十进制数:";
    cin>>a;
    while(a)
    {
        Push(s,a%t);
        a=a/t;
    }
    while(!stackempty(s))
    {
        Pop(s,e);
        cout<<e;
    }
    return 0;
}

//7. 利用队列打印杨辉三角：编写程序，根据输入的行数，屏幕显示杨辉三角。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXSIZE=100;
typedef struct
{
    int *data;
    int front,rear;
} SeQueue;
int n;
bool InitQueue(SeQueue &Q)
{
    Q.data = (int *) malloc (MAXSIZE * sizeof(int));
    if (!Q.data) {printf("OVERFLOW\n");return 0;}
    Q.front=0;
    Q.rear=0;
    return 1;
}
bool EnQueue(SeQueue &Q, int e)
{
    if ( (Q.rear+1) % MAXSIZE == Q.front ) {printf("OVERFLOW\n");return 0;}
    Q.data[++Q.rear] = e;
    Q.rear=(Q.rear+1) % MAXSIZE;
    return 1;
}

bool DeQueue(SeQueue &Q, int &e)
{
    if (Q.front == Q.rear) {printf("UNDERFLOW\n");return 0;}
    e = Q.data[++Q.front];
    Q.front=(Q.front+1) % MAXSIZE;
    return 1;
}

int gethead(SeQueue &Q, int &e)
{
    if (Q.front == Q.rear) {printf("UNDERFLOW\n");return 0;}
    e = Q.data[++Q.front];
    return 1;
}

void GetTriangle(SeQueue &Q, int e)
{
    int cur=0;
    int pre;
    for(int i=1; i<=n-e; i++)
        printf("   ");
    for(int i=0; i<=e; i++)
    {
        pre=cur;
        DeQueue(Q,cur);
        printf("%3d   ",cur);
        EnQueue(Q,cur+pre);
    }
    EnQueue(Q,cur);
    printf("\n");
}

int main()
{
    while(1)
    {
        printf("输入一个正整数表示你所需要的杨辉三角阶数(0~15)： ");
        if (scanf("%d",&n)==EOF) break;
        printf("\n");
        SeQueue Q;
        InitQueue(Q);
        EnQueue(Q,1);
        for(int i=0; i<=n; i++)
        {
            GetTriangle(Q,i);
        }
    }
    return 0;
}