顺序栈
main.cpp

#include<iostream>
#include"sqstack.h"
using namespace std;
int main()
{
	SqStack *LS;
	ElemType ch[5] = { 'a','b','c','d','e' };
	InitStack(LS);
	if (StackEmpty(LS))
		cout << "Stack is empty" << endl;
	for (int i = 0; i < 5; i++)
		Push(LS, ch[i]);
	if (!StackEmpty(LS))
		cout << "Stack is not empty" << endl;
	cout << "Length of Stack is " << StackLength(LS) << endl;
	DispStack(LS);
	for (int i = 0; i < 5; i++)
	{
		Pop(LS, ch[i]);
		cout << ch[i] << " ";
	}
	if (StackEmpty(LS))
		cout << "Stack is empty" << endl;
	DestroyStack(LS);
	return 0;
}

sqstack.cpp

#include <stdio.h>
#include <malloc.h>
#include "sqstack.h"

void InitStack(SqStack *&s)
{
    s=(SqStack *)malloc(sizeof(SqStack));
    s->top=-1;
}
void DestroyStack(SqStack *&s)
{
    free(s);
}
int StackLength(SqStack *s)  //返回栈中元素个数——栈长度
{
    return(s->top+1);
}
bool StackEmpty(SqStack *s)
{
    return(s->top==-1);
}
bool Push(SqStack *&s,ElemType e)
{
    if (s->top==MaxSize-1)    //栈满的情况，即栈上溢出
        return false;
    s->top++;
    s->data[s->top]=e;
    return true;
}
bool Pop(SqStack *&s,ElemType &e)
{
    if (s->top==-1)     //栈为空的情况，即栈下溢出
        return false;
    e=s->data[s->top];
    s->top--;
    return true;
}
bool GetTop(SqStack *s,ElemType &e)
{
    if (s->top==-1)         //栈为空的情况，即栈下溢出
        return false;
    e=s->data[s->top];
    return true;
}

void DispStack(SqStack *s)  //输出栈
{
    int i;
    for (i=s->top;i>=0;i--)
        printf("%c ",s->data[i]);
    printf("\n");
}

sqstack.h

#ifndef SQSTACK_H_INCLUDED
#define SQSTACK_H_INCLUDED

#define MaxSize 100
typedef char ElemType;
typedef struct
{
    ElemType data[MaxSize];
    int top;                //栈指针
} SqStack;                  //顺序栈类型定义

void InitStack(SqStack *&s);    //初始化栈
void DestroyStack(SqStack *&s);  //销毁栈
bool StackEmpty(SqStack *s);     //栈是否为空
int StackLength(SqStack *s);  //返回栈中元素个数——栈长度
bool Push(SqStack *&s,ElemType e); //入栈
bool Pop(SqStack *&s,ElemType &e); //出栈
bool GetTop(SqStack *s,ElemType &e); //取栈顶数据元素
void DispStack(SqStack *s);  //输出栈

#endif // SQSTACK_H_INCLUDED

链栈
main.cpp

#include<iostream>
#include"listack.h"
using namespace std;
int main()
{
	LiStack *LS;
	ElemType ch[5] = { 'a','b','c','d','e' };
	InitStack(LS);
	if (StackEmpty(LS))
		cout << "Stack is empty" << endl;
	for (int i = 0; i < 5; i++)
		Push(LS, ch[i]);
	if (!StackEmpty(LS))
		cout << "Stack is not empty" << endl;
	cout << "Length of Stack is " << StackLength(LS) << endl;
	DispStack(LS);
	for (int i = 0; i < 5; i++)
	{
		Pop(LS, ch[i]);
		cout << ch[i] << " ";
	}
	if (StackEmpty(LS))
		cout << "Stack is empty" << endl;
	DestroyStack(LS);
	return 0;
}

listack.cpp

#include <iostream>
#include <malloc.h>
#include "listack.h"

void InitStack(LiStack *&s)  //初始化栈
{
    s=(LiStack *)malloc(sizeof(LiStack));
    s->next=NULL;
}

void DestroyStack(LiStack *&s)  //销毁栈
{
    LiStack *p=s->next;
    while (p!=NULL)
    {
        free(s);
        s=p;
        p=p->next;
    }
    free(s);    //s指向尾结点,释放其空间
}

int StackLength(LiStack *s)  //返回栈长度
{
    int i=0;
    LiStack *p;
    p=s->next;
    while (p!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}

bool StackEmpty(LiStack *s)  //判断栈是否为空
{
    return(s->next==NULL);
}

void Push(LiStack *&s,ElemType e)  //入栈
{
    LiStack *p;
    p=(LiStack *)malloc(sizeof(LiStack));
    p->data= e;              //新建元素e对应的节点*p
    p->next=s->next;        //插入*p节点作为开始节点
    s->next=p;
}

bool Pop(LiStack *&s,ElemType &e)  //出栈
{
    LiStack *p;
    if (s->next==NULL)      //栈空的情况
        return false;
    p=s->next;              //p指向开始节点
    e=p->data;
    s->next=p->next;        //删除*p节点
    free(p);                //释放*p节点
    return true;
}

bool GetTop(LiStack *s,ElemType &e)  //取栈顶元素
{
    if (s->next==NULL)      //栈空的情况
        return false;
    e=s->next->data;
    return true;
}

void DispStack(LiStack *s)  //输出栈中元素
{
    LiStack *p=s->next;
    while (p!=NULL)
    {
		std::cout << p->data;
        p=p->next;
    }
	std::cout << std::endl;
}

listack.h

#ifndef LISTACK_H_INCLUDED
#define LISTACK_H_INCLUDED

typedef  int  ElemType;
typedef struct linknode
{
    ElemType data;              //数据域
    struct linknode *next;      //指针域
} LiStack;                      //链栈类型定义

void InitStack(LiStack *&s);  //初始化栈
void DestroyStack(LiStack *&s);  //销毁栈
int StackLength(LiStack *s);  //返回栈长度
bool StackEmpty(LiStack *s);  //判断栈是否为空
void Push(LiStack *&s,ElemType e);  //入栈
bool Pop(LiStack *&s,ElemType &e);  //出栈
bool GetTop(LiStack *s,ElemType &e);  //取栈顶元素
void DispStack(LiStack *s);  //输出栈中元素


#endif // LISTACK_H_INCLUDED