栈和队列的操作一——栈的顺序存储结构

前置知识点

顺序栈空：S.top=S.base;

顺序栈满：S.top-S.base=S.stacksize;

顺序栈长：S.top-S.base;

emm...栈是后进先出的，只能在尾部进行插入或删除。表尾端也叫做“栈顶”，表头端也叫做“栈底”。

 

一、栈的顺序存储结构

 base为栈底指针，初始化完成时，栈底指针base始终指向栈底的位置，若base为NULL时，表明站的结构不存在。

top为栈顶指针，初值指向栈底，当插入新的栈顶元素时，指针top增1；删除栈顶元素时，top减1。

栈为空时，top和base的值相等，都指向栈底；栈非空时，top始终指向栈顶元素的上一个位置。

顺序栈的实验要实现的是：

 

接下来，就开始写代码吧

最重要的，存储结构！！！可我为啥老是记不住嘞

 1.定义存储结构

两个 SElemType 类型的指针，栈顶指针top，栈底指针base,栈的长度stacksize;

typedef struct
{
        SElemType *base;

        SElemType *top;

        int stacksize;
}SqStack;

2.初始化顺序栈

静态分配存储空间 S.base = new SElemType[MAXSIZE];栈顶指针和栈底指针指向栈底，栈的长度为最大长度MAXSIZE.

void InitStack(SqStack &S)
{
    S.base=new SElemType[MAXSIZE];    //静态分配存储空间
    S.top=S.base;
    S.stacksize=MAXSIZE;
}

3.判断顺序栈是否为空

直接返回S.top==S.base(栈空)即可.

bool StackEmpty(SqStack S)
{
    return S.base==S.top;
}

4.求顺序栈的长度

顺序栈的长度=S.top-S.base;

int StackLength(SqStack S)
{
    return S.top-S.base;
}

5.入栈

思路：先判断栈是否满了，因为满了嘞，就不能进去了。不满的话，就将栈顶指针指向的空间赋值为e，然后嘞，栈顶指针再往上走一个位置。

Status Push(SqStack &S,SElemType e)
{
    if(S.top-S.base==S.stacksize)
        return ERROR;
    *S.top=e;
    S.top++;
    return OK;
}

6.出栈

思路：先判断栈是否为空，如果为空的话，一个元素都没有了，还怎么出栈呢

不空的话，就先让栈顶指针往下移一个位置。再将出栈的元素赋值给e，因为最后会把e给输出出来滴。

Status Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)
        return ERROR;
    --S.top;
    e=*S.top;
    return OK;
}

7.获取栈顶元素

思路：还是一样，emm，先判断栈是否空。不空时：将栈底指针往下移一个，再把元素取出来给e就可以啦...

Status GetTop(SqStack S,SElemType &e)
{
    if(S.top==S.base)
        return ERROR;
    e=*(S.top-1);
    return OK;
}

8.显示顺序栈

思路：不要忘了，栈是后进先出。所以应该从栈顶一次出栈。

先生成一个指针p指向S.top的位置，当p不指向栈底指针时，--p;输出*p就可以啦。

void DisplayStack(SqStack S)
{
    SElemType *p=S.top;
    while(p!=S.base)
    {
        --p;
        cout<<*p<<" "<<endl;
    }
    cout<<endl;
}

9.清空顺序栈

思路：S.top=S.base。清空是保留栈，销毁是把整个栈都销毁。

void ClearStack(SqStack &S)
{
    S.top=S.base;
}

10.销毁顺序栈

思路：如果S.base不为空时，删除S.base;  S.stacksize置为0；栈顶指针，栈底指针置为NULL。

void DestoryStack(SqStack &S)
{
    if(S.base)
    {
        delete[] S.base;
        S.stacksize=0;
        S.top=S.base=NULL;
    }
}

emm，基本操作就写完了。

完整代码

//顺序栈
#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define MAXSIZE 100

typedef int SElemType;
typedef int Status;

typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;

void InitStack(SqStack &S)
{
    S.base=new SElemType[MAXSIZE];//静态分配存储空间
    S.top=S.base;
    S.stacksize=MAXSIZE;
}

bool StackEmpty(SqStack S)
{
    return S.base==S.top;
}

int StackLength(SqStack S)
{
    return S.top-S.base;
}

Status Push(SqStack &S,SElemType e)
{   //先判断是否满了
    if(S.top-S.base==S.stacksize)
        return ERROR;
    *S.top=e;
    S.top++;
    return OK;
}

Status Pop(SqStack &S,SElemType &e)
{
    //先判断栈是否空
    if(S.top==S.base)
        return ERROR;
    --S.top;
    e=*S.top;
    return OK;
}

Status GetTop(SqStack S,SElemType &e)
{
    //先判断栈是否空
    if(S.top==S.base)
        return ERROR;
    e=*(S.top-1);
    return OK;
}

void DispalyStack(SqStack S)
{
    SElemType *p=S.top;//先生成一个int类型的指针指向S.top的位置
    while(p!=S.base)
    {
        --p;
        cout<<*p<<" "<<endl;
    }
    cout<<endl;
}

void ClearStack(SqStack &S)
{
    S.top=S.base;
}

void DestoryStack(SqStack &S)
{
    if(S.base)
    {
        delete[] S.base;
        S.stacksize=0;
        S.base=S.top=NULL;
    }
}

void show_help()
{
    cout<<"1----清空顺序栈"<<endl;
    cout<<"2----判断顺序栈是否为空"<<endl;
    cout<<"3----求顺序栈长度"<<endl;
    cout<<"4----入栈"<<endl;
    cout<<"5----出栈"<<endl;
    cout<<"6----求栈顶元素"<<endl;
    cout<<"7----显示顺序栈"<<endl;
    cout<<"     退出，输出一个负数！"<<endl;
}

int main()
{
     int operate_code;
    show_help();
    //定义线性表变量，如SqList L;
    SqStack S;
    InitStack(S);


    while(1)
    {
        cout<<"请输入操作代码：";
        cin>>operate_code;
        if(operate_code==1)
        {
            ClearStack(S);
        }
        else if(operate_code==2)
        {
            if(!StackEmpty(S))
                cout<<"The LinkList is not Empty"<<endl;
            else
                cout<<"The LinkList is Empty"<<endl;
        }
        else if(operate_code==3)
        {
            cout<<StackLength(S)<<endl;
        }
        else if(operate_code==4)
        {
            SElemType e;
            cin>>e;
            Push(S,e);

        }
        else if(operate_code==5)
        {
            SElemType e;
            if(Pop(S,e))
                cout<<"栈顶元素"<<e<<"出栈成功"<<endl;
            else
                cout<<"栈为空"<<endl;

        }
        else if(operate_code==6)
        {
            SElemType e;
            if(GetTop(S,e))
                cout<<"栈顶元素为："<<e<<endl;
            else
                cout<<"空栈，无栈顶元素！"<<endl;
        }
        else if(operate_code==7)
        {
            DispalyStack(S);
        }
        else if(operate_code<0)
        {
            break;
        }
        else
        {
            cout<<"\n操作码错误！！！"<<endl;
            cin.clear();
            cin.sync();
            show_help();
        }


    }
    //调用销毁线性表函数，如  Destroy_List(L);
    DestoryStack(S);
    return 0;
}