C++栈的实现

2009-04-15 11:40
顺序栈(seqential stack)就是用顺序存储方式存储的栈。在下面顺序栈的类定义中是用数组存储的。用stacka[maxsize]存储，maxsize是最大允许存放元素的个数。变量top表示栈顶部元素的位置,初始值为-1,表示栈空.
      我们首先给出顺序栈的抽象数据类型的描述,然后给出顺序栈的类定义与实现。下面是顺序栈的抽象数据类型的描述。
      ADT seqstack is
       Data 
           栈顶表示，存放栈元素组和栈元素个数的最大数
         seqstack
              输入:栈元素个数的最大数
       　~seqstack
              删除存储栈元素的数组
       Push
              输入：要进栈的项item
              前置条件：栈末满
              动作：把item压入栈顶
              输出：无
              后置条件：栈顶增加了一个新元素，栈顶指示加1
       Pop
              输入：无
              前置条件：栈非空
              动作：弹出栈顶元素
              输出：返回栈顶元素的值
              后置条件：删除栈顶元素，栈顶指示减1
Gettop
              输入：无
              前置条件：栈非空
              动作：取栈顶元素值
              输出：返回栈顶数据元素
              后置条件：无
       Empty
              输入：无
              前置条件：无
              动作：检查栈顶指示是否等于－1
              输出：栈空时返回1，否则返回0
              后置条件：无
       Full
              输入：无
              前置条件：无
              动作：检查栈顶指示是否等于maxsize-1
              输出：栈满时返回1，否则返回0
              后置条件：无
       Clear
              输入：无
              前置条件：无
              动作：清空栈
              输出：无
              后置条件：栈顶指示为－1
End ADT seqstack
//
/*
**=======================================
**SeqStack.h           顺序栈模板类的定义及实现
**=======================================
*/
#include <iostream.h>
#include <stdlib.h>
/


#define MAXSIZE   0xFFFF
template<class type>
class SeqStack 
{
int   top;     //栈顶指示
type *stacka;    //数组名
int   maxsize;    //栈最大可容纳元素个数
public:
SeqStack();
SeqStack(int size);
SeqStack(type data[],int size);
virtual ~SeqStack()
{
   delete []stacka;
}
void Push(const type &item);    //元素item压栈
type Pop();        //数据元素出栈,返回之
type GetTop();       //读栈顶数据元素并返回


int   Empty()const
{
   return top==-1;
}           //判断栈是否为空
int   Full()const
{
   return top==maxsize-1;
}           //判断栈是否为满
void Clear()
{
   top=-1;
}           //清空栈
};


template<class type>
SeqStack<type>::SeqStack():
top(-1),maxsize(MAXSIZE)
{
stacka=new type[maxsize];
if(stacka==NULL){
   cerr<<"动态存储分配失败!"<<endl;
   exit(1);
}
}
template<class type>
SeqStack<type>::SeqStack(int size):
top(-1),maxsize(size)
{
stacka=new type[maxsize];    //创建存储栈的数组
if(stacka==NULL){      //分配不成功
   cerr<<"动态存储分配失败!"<<endl;
   exit(1);
}
}
template<class type>
SeqStack<type>::SeqStack(type data[],int size):
top(-1),maxsize(size)
{
stacka=new type[maxsize];    //创建存储栈的数组
if(stacka==NULL){      //分配不成功
   cerr<<"动态存储分配失败!"<<endl;
   exit(1);
}
for(int i=0;i<maxsize;i++){
   stacka[i]=data[i];
}


top+=maxsize;
}


template<class type>
void SeqStack<type>::Push(const type& item)
{
//若栈已满，出错处理；否则把元素item压栈
if(Full()){         
   cerr<<"栈已满，不能压栈!"<<endl;
   exit(1);
}
//这里我们采用指针先移动，然后再对元素进行操作的方式
top++;   


stacka[top]=item;
}


template<class type>
type SeqStack<type>::Pop()
{
if(Empty()){
   cerr<<"栈已空!"<<endl;
   exit(1);
}
//栈不空，取栈顶元素
type data=stacka[top];
top--;
//返回栈顶元素
return data;
}


template<class type>
type SeqStack<type>::GetTop()
{
//若栈不空，返回栈顶元素的值
if(Empty()){
   cerr<<"栈空!"<<endl;
   exit(1);
}
//返回栈顶元素的值
return stacka[top];
}
//
/*
**=======================================
**main.h           主程序
**=======================================
*/


#include "SeqStack.h"
int main()
{
int data[10]={1,2,3,4,5,6,7,8,9,10};
SeqStack<int> stack(data,10);
while(!stack.Empty()){
   cout<<stack.Pop()<<" ";
}
cout<<endl;
return 0;
}

输出结果：
10 9 8 7 6 5 4 3 2 1
Press any key to continue