栈的顺序.链式实现

用顺序表示的栈的实现：

#include <iostream.h>
#define OVERFLOW 0//定义“溢出”为0
#define ERROR 0
#define OK 1
#define MAXSIZE 100//顺序栈存储空间的初始分配量
 
typedef int SElemType;//SElemType为数据类型
typedef int Status;//定义结构体
 
//顺序栈的类型定义
typedef struct
{
    SElemType *base;//栈底指针
    SElemType *top;//栈顶指针
    int stacksize;//栈的最大容量
}SqStack;//SqStack就是问题中声明的类型，后续可以用它来定义变量
 
 
//栈的初始化:初始化，初始化操作就是为栈动态分配一个预定义大小的数组空间，base指向栈底，top 初始值也指向栈底，表示栈空，stacksize置为栈的最大容量
Status InitStack(SqStack &S)//栈的初始化，构造一个空栈s
{
    S.base=new SElemType[MAXSIZE];//为顺序栈分配一个最大容量为MAXSIZE 的数组空间
    if(!S.base)
        return OVERFLOW;//存储分配失败
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}
 
 
//顺序栈的入栈，入栈操作是指在栈顶插入一个新的元素，首先判断栈是否满，若满则报错，否则将新元素压入栈顶，栈顶//指针加1
Status Push(SqStack &S,SElemType e)
{
    if(S.top-S.base==S.stacksize)
        return ERROR;判断栈是否为空，为空报错
    *S.top++=e;//等价于*S.top=e;S.top++;目的是将e压入栈顶，栈顶指针加1
    return OK;
}
 
 
//顺序栈的出栈：出栈操作是将栈顶元素删除。首先判断栈是否为空，若空则报错，否则栈顶指针减1，栈顶元素出栈
Status Pop(SqStack &S,SElemType&e)
{
    if(S.top==S.base)
        return ERROR; //判断栈是否为空，为空报错
    e=*--S.top;//等价于S.top--;*S.top=e;目的是栈顶指针减1并将栈顶元素赋给e
    return OK;
}
 
 
 
 
//取顺序栈的栈顶元素
Status GetTop(SqStack S,SElemType &e)//返回s的栈顶元素，不修改栈顶指针
{
    if(S.top==S.base)
        return ERROR; //判断栈是否为空，为空报错
    e=*(S.top-1);
    return OK;
}
 
 
bool StackEmpty(SqStack S)//若s为空栈，返回true，否则返回false
{
    if(S.top==S.base)
        return true;
    else
        return false;
}
 
 
int StackLength(SqStack S)//返回s的元素个数，即栈的长度
{
    return S.top-S.base;
}
 
 
int main()
{
    SqStack s;
    int i,e;
    if(InitStack(s))
        cout<<"成功初始化栈！\n";
    for(i=0;i<5;i++)
    {
        cout<<"请输入第"<<i+1<<"个元素：";
        cin>>e;
        Push(s,e);
    }
    if(GetTop(s,e))
    {
        cout<<"\n栈顶元素为：";
        cout<<e<<"\n";
    }
    cout<<"\n弹出栈的元素依次为：";
    while(Pop(s,e))
        cout<<e<<" ";
    cout<<"\n";
    return 0;}

用链表示的栈的实现：

#include<cstdio>
#include<cstdlib> 
#define MAXSIZE 1000    //链表的最大长度 
#define SElemType int 
#define Status int 
//栈的结构
typedef struct LStack{
    SElemType data;        //数据域
    struct LStack *next;    //指针域 
}LStack,*LStackList; 
 
//初始化
Status InitStack(LStackList &S){
    S = new LStack;
    S->next = NULL;
    return 0; 
}
 
//入栈
Status Push(LStackList &S,SElemType e){    
    LStackList p = new LStack;        //生成新的结点 
    p->data = e;    //新结点的数据域赋值 
    p->next = S;    //新结点的指针域指向头结点（栈顶） 
    S=p;    //链表的表头更新为新插入的元素； 
    printf("压入栈成功\n");
    return 0; 
} 
 
//出栈
Status Pop(LStackList &S){
    if(S->next){
        LStackList p = S;
        S=S->next;    //头指针后移 
        free(p);
        printf("出栈成功\n"); 
    }else{
        printf("栈空\n"); 
    }
} 
 
//创建栈，就是重复的将元素入栈（当然也可以单独写一个创建的函数）
void Creat(LStackList &S,int n){
    InitStack(S);
    for(int i=0;i<n;i++){
        int e;
        scanf("%d",&e); 
        Push(S,e);
    }
    printf("创建成功\n");
}  
 
//遍历，因为是从栈顶（表头）开始的遍历，所以输出的列表是逆序的 
Status StackTraverse(LStackList S){
    printf("遍历开始：\n");
    LStackList p = S;
    /**
    注意：最后一个链表是没有元素的 
    */ 
    while(p->next){        //最后一个链表是没有元素的 
        printf("%d ",p->data);
        p = p->next;
    } 
    printf("\n"); 
} 
 
//获取栈的元素个数 
Status StackLength(LStackList S){
    LStackList p = S;
    int count=0;
    while(p){
        p = p->next;
        count++;
    } 
    printf("栈内元素个数为：%d\n",count); 
} 
 
//判断栈空
bool StackEmpty(LStackList S){
    if(S->next == NULL){
        printf("栈空\n");
        return true; 
    }else{
        printf("栈非空\n");
        return false;
    } 
} 
 
//获取栈顶元素
Status GetTop(LStackList S,SElemType e){
    //判断栈空 
    if(StackEmpty(S)){
        return 0;
    }else{
        e = S->data;
        printf("栈顶元素为%d\n",e);
        return 0;
    } 
} 
 
//栈置空
Status ClearStack(LStackList &S){
    if(S->next != NULL)
        S->next = NULL;
    printf("置空操作成功\n");
    return 0; 
}
 
//销毁链表
Status DestoryStack(LStackList &S){
    //判断是否为空表 
    LStackList p = S;
    LStackList pre = new LStack; 
    while(p->next){
        pre = p;
        p = p->next;
        delete(pre);
    } 
    printf("销毁链表成功\n");
    return 0; 
} 
 
 
int main(){
    int n,value1,value2;
    LStackList S;
    printf("请输入元素个数:");                        
    scanf("%d",&n);
    Creat(S,n);
    StackTraverse(S);
    StackLength(S);
    GetTop(S,value1);
    Pop(S);
    StackTraverse(S);
    GetTop(S,value1);
    ClearStack(S);
    StackTraverse(S);
    DestoryStack(S);
    return 0; 
}