templateclass type class abstack public bool Is Empty

Ø 栈的抽象类定义 template<class type> //定义一个抽象的模板堆栈类 class abstack { public: bool Is. Empty( ) //判断堆栈是否为空 { return (height==0)? true: false; } //进栈函数，将一元素压入栈中 virtual void Push(type&)=0; //出栈函数，从栈中取一元素 virtual bool Pop(type&)=0; //清栈函数，用于释放栈所占的内存空间 virtual void Clear( )=0; protected : unsigned height; }; //栈高

//清栈函数，用于释放栈所占的内存空间 void Clear( ){ delete elements; } Seq. Stack & Copy(Seq. Stack & s); //拷贝函数: 同类型栈赋值 //重载赋值运算符“＝”，用于同类型栈赋值 Seq. Stack & operator=(Seq. Stack & s) {delete elements; Copy(s); return *this; } bool Is. Full( ) //判断栈是否为满 {return top= =maxsize-1; } // top= =maxsize-1为关系表达式 protected: int top; //栈顶指针 type *elements; //一维数组指针，用于存放栈中元素 int maxsize; //栈的最大高度 };

template<class type> Seq. Stack<type>: : Seq. Stack(int i) { height = 0; //abstack抽象类的数据成员 top = -1; maxsize = i>10 ? i: 10; //最大栈高最小为 10 elements = new type[maxsize]; assert (elements!=0); //条件满足，继续执行; 否则终止 }

template<class type> //函数模板 void Seq. Stack<type>: : Push(type & x ) { assert(!Is. Full( )); //栈满警告，出错处理 elements[++top] = x; //将栈顶指针加 1，将元素放入栈顶 height++; } //栈高加 1

template<class type> bool Seq. Stack<type>: : Pop(type & x) { if(Is. Empty( )) //栈空警告，出错处理 return false; else { x = elements[top]; //取出栈顶元素，将其值放入x 中 top- -; //栈顶指针减 1 height- -; //栈高减 1 } return true; }

链式栈类的定义：链栈模板 template<class type> //定义一个栈类模板 class Link. Stack: public abstack<type> { protected: Stack. Node<type>*top; //栈顶指针 //复制函数，将堆栈g复制给本链式栈 Link. Stack & Copy(Link. Stack & g); public: Link. Stack( ); //无参构造函数 Link. Stack(Link. Stack & g) //拷贝构造函数 { top=NULL; Copy(g); }

Ø 构造函数初始化数据成员值，构造一个空栈。 template<class type> Link. Stack<type>: : Link. Stack( ) { height=0; top=NULL; }

Ø 出栈函数 template<class type> bool Link. Stack<type>: : Pop(type& x) { Stack. Node<type>*p; if(height) //若栈中有元素 { x=top->data; //将栈顶结点的数据元素赋给x p=top; //将栈顶指针赋给p top=top->next; //修改栈顶指针，下移一个位置 delete p; //删除原栈顶结点 height--; //栈高减 1 return true; } return false; }

3. 2 栈的应用举例表达式求值示意： 5 + 6 ( 1 + 2 ) - 4 = 19 读入表达式过程： 5 + 6 ×( 1 + 2 ) - 4 # OPTR栈 OPND栈 1+2=3 6× 3=18 5+18=23 23 -4=19 top top base + ( × +# top top toptop base 2 31 18 46 23 19 5

Ø 抽象队列类 template<class type> class abque //定义抽象队列类模板 { protected : int qsize; //队列长度 public: bool Is. Empty( ) //判队列是否为空 { return (qsize==0)? true: false; } virtual void Push. Tail(type&)=0; //将元素插入队尾 virtual bool Pop. Front(type&)=0; //从对头提取元素 virtual void Clear( )=0; //清空队列 };

rear front a 3 front 元素a 2出队后的状态 rear 元素a 3出队后的状态 front rear

n 队空：front==rear front rear 少用一个元素空间：队空：front==rear 队满：(rear+1)%M==front rear 6 J , 5 J 4, J 队出 J 6 J 5 front J 4 4 3 5 2 4 3 0 1 5 2 0 1 J 7 , 入 J 8 队 J 6 J 5 队满：front==(rear+1)%M front rear J 4 4 5 0 3 1 2 J 7 J 8

3、循环队列类的定义 template<class type> class Seq. Quene: public abque<type> {protected: int head； //队头指针 int tail; //队尾指针 type *elements; //存放队列元素的数组 int maxsize; //队列最大可容纳元素个数 Seq. Quene & Copy(Seq. Quene & q); //队列拷贝函数 public: Seq. Quene(int i=10); //构造函数，缺省参数 ~ Seq. Quene( ) //析构函数 { Clear( ); }

void Push. Tail (type &); //将新元素插入在队尾 bool Pop. Front (type &); //从队头取一个元素 void Clear( ) //清空队列 { delete elements; } //重载赋值运算符，用来对同类队列赋值 Seq. Quene & operator=(Seq. Quene & q) { Copy(q); const的含义：该成 return *this; } 员函数的算法不修改 bool Is. Full( ) const 该类的成员变量的值 //判队列是否为满 { return(tail+1)%maxsize==head; } bool Is. Empty( ) //判队列是否为空 { return head==tail; } };

链式队列图示 head tail a 1 a 2 an 非空链队列 head NULL tail NULL 空的链队列 head tail a 1

n 链式队列类的定义 template<class type> //定义链式队列类 class Link. Quene: public abque <type> {protected: Quene. Node<type> *head; //队头 Quene. Node<type> *tail; //队尾 //队列拷贝函数 Link. Quene & Copy(Link. Quene & q)； public: Link. Quene( ); //构造函数

Link. Quene(Link. Quene & q) //拷贝构造函数 { head=NULL; tail=NULL; Copy(q); } ~Link. Quene( ) //析构函数 { Clear( ); } void Push. Tail(type &); //将新元素插入在队尾 bool Pop. Front(type &); //从队头取一个元素 void Clear( ); //清空队列 //重载赋值运算符，对同类队列赋值 Link. Quene & operator=(Link. Quene & q) { Copy(q); return *this; } };