顺序栈的c语言实现和OOP实现

• C语言实现顺序栈和OOP实现顺序栈
  • 1,顺序栈
  • 2，C语言实现顺序栈
  • 3,用OOP实现一个顺序栈

C语言实现顺序栈和OOP实现顺序栈

1,顺序栈

（1）定义：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

（2）栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表，它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

（3）图解：

2，C语言实现顺序栈

#include<stdio.h>
#include<assert.h>
#define STACK_LEN 5
typedef struct Sqstack
{
    int elem[STACK_LEN];
    int top;//当前可存放数据的下标
}Sqstack,*Pstack;
void InitStack(Pstack ps)
{
    assert(ps!=NULL);
    ps->top=0;
}
bool Push(Pstack ps,int val)//压栈
{
    assert(ps!=NULL);
    if(Isfull(ps))
    {
        return false;
    }
    ps->elem[ps->top++]=val;
    return true;
}
bool Pop(Pstack ps,int *rtv)//删除、出栈
{
    assert(ps!=NULL);
    if(IsEmpty(ps))
    {
         return false;       
    }
    if(rtv!=NULL)
    {
        ps->top--;
        *rtv=ps->elem[ps->top];
    }
}
bool GetTop(Pstack ps,int *rtv)//得到栈顶元素， 但是不删除
{
    assert(ps!=NULL);
    if(IsEmpty(ps))
    {
        return false;
    }
    if(rtv!=NULL)
    {
        *rtv=ps->elem[ps->top-1];
    }
}
bool IsEmpty(Pstack ps)//判空
{
    assert(ps!=NULL);
    return ps->top==0;
}
bool Isfull(Pstack ps)//判满
{
    assert(ps!=NULL);
    return ps->top==STACK_LEN;
}
void Clear(Pstack ps)//top 指针的操作
{
    ps->top=0;
}
void Destroy(Pstack ps);//这里没有动态内存分配
{
    Clear(ps);
}
void Show(Pstack ps)
{
    for(int i=0;i<ps->top;i++)
    {
        printf("%d ",ps->elem[i]);
    }
    printf("\n");
}

3,用OOP实现一个顺序栈

#include<iostream>
using namespace std;

class CStack
{
 public:
    CStack()        //默认构造函数
    {
        mtop=0;
        msize=10;
        mStack=new int[msize];
    }
    /*CStack(int size=10)   //带参数的构造函数
    {
        mtop=0;
        msize=size;
        mStack=new int[msize];
    }*/
    
    ~CStack()                        //析构
    {
        delete[]mStack;
        mStack=NULL;
    }
    
     void push(int val)                 //入栈
     {
         if(full())
         {
             resize();
         }
         mStack[mtop++]=val;
     }
    
    void pop()                     //出栈
    {
        if(empty())
        {
            return ;
        }
        mtop--;
    }
    
    int top()                      //获取栈顶元素
    { 
       return mStack[mtop-1]; 
    }
    
    bool full()              //判满
    {
        return mtop==msize;
    }
    bool empty()              //判空
    {
        return mtop==0;
    }
  private:
    int*mStack;
    int mtop;
    int msize;
    void resize()                //二倍扩容
    {
        int *mtmp=new int[msize*2];
        for(int i=0;i<msize;i++)
        {
            mtemp[i]=mStack[i];
        }
        delete[]mStack;
        mStack=mtmp;
        msize*=2;
    }
};