第三章 栈与队列 总结

栈：限定仅在表尾进行插入和删除操作的线性表
栈的抽象数据类型定义
ADT Stack
Data
栈中元素具有相同类型及后进先出特性，
相邻元素具有前驱和后继关系
Operation
InitStack
前置条件：栈不存在
输入：无
功能：栈的初始化
输出：无
后置条件：构造一个空栈

DestroyStack
前置条件：栈已存在
输入：无
功能：销毁栈
输出：无
后置条件：释放栈所占用的存储空间
Push
前置条件：栈已存在
输入：元素值x
功能：在栈顶插入一个元素x
输出：如果插入不成功，抛出异常
后置条件：如果插入成功，栈顶增加了一个元素

Pop
前置条件：栈已存在
输入：无
功能：删除栈顶元素
输出：如果删除成功，返回被删元素值，否则，抛出异常
后置条件：如果删除成功，栈减少了一个元素
GetTop
前置条件：栈已存在
输入：无
功能：读取当前的栈顶元素
输出：若栈不空，返回当前的栈顶元素值
后置条件：栈不变
Empty
前置条件：栈已存在
输入：无
功能：判断栈是否为空
输出：如果栈为空，返回1，否则，返回0
后置条件：栈不变
endADT

顺序栈类的声明
const int MAX_SIZE=100;
template
class seqStack
{
public:
seqStack ( ) ;
~seqStack ( );
void Push ( T x );
T Pop ( );
T GetTop ( );
bool Empty ( );
private:
T data[MAX_SIZE];
int top;
}

顺序栈的实现——入栈
操作接口： void Push( T x );
template
void seqStack::Push ( T x)
{
if (top==MAX_SIZE-1) throw “溢出”;
top++;
data[top]=x;
}
顺序栈的实现——取栈顶
操作接口： T GetTop( );
template
T seqStack::GetTop ( )
{
if (Empty()) throw ”空栈” ；
return data[top];
}
顺序栈的实现——出栈
操作接口： T Pop( );

template
T seqStack:: Pop ( )
{
if (top==-1) throw “溢出”;
x=data[top];
top–;
return x;
}

链栈的类声明
template
class LinkStack
{
public:
LinkStack( ) {top=NULL;};
~LinkStack( );
void Push(T x);
T Pop( );
T GetTop( );
bool Empty( );
private:
Node *top;
}

特殊线性表——队列
队列的抽象数据类型定义

ADT Queue
Data
队列中元素具有相同类型及先进先出特性，
相邻元素具有前驱和后继关系
Operation
InitQueue
前置条件：队列不存在
输入：无
功能：初始化队列
输出：无
后置条件：创建一个空队列
DestroyQueue
前置条件：队列已存在
输入：无
功能：销毁队列
输出：无
后置条件：释放队列所占用的存储空间
EnQueue
前置条件：队列已存在
输入：元素值x
功能：在队尾插入一个元素
输出：如果插入不成功，抛出异常
后置条件：如果插入成功，队尾增加了一个元素
DeQueue
前置条件：队列已存在
输入：无
功能：删除队头元素
输出：如果删除成功，返回被删元素值
后置条件：如果删除成功，队头减少了一个元素
GetQueue
前置条件：队列已存在
输入：无
功能：读取队头元素
输出：若队列不空，返回队头元素
后置条件：队列不变
Empty
前置条件：队列已存在
输入：无
功能：判断队列是否为空
输出：如果队列为空，返回1，否则，返回0
后置条件：队列不变
endADT

循环队列类的声明
const int QueueSize=100;
template
class CirQueue{
public:
CirQueue( )；
~ CirQueue( )；
void EnQueue(T x);
T DeQueue( );
T GetQueue( );
bool Empty( ){
if (rearfront) return true;
return false;
}；
private:
T data[QueueSize];
int front, rear;
};
循环队列的实现——入队
template
void CirQueue::EnQueue(T x)
{
if ((rear+1) % QueueSize front) throw “上溢”;
rear=(rear+1) % QueueSize;
data[rear]=x;
}
循环队列的实现——出队
template
T CirQueue::DeQueue( )
{
if (rearfront) throw “下溢”;
front=(front+1) % QueueSize;
return data[front];
}
循环队列的实现——读队头元素
template
T CirQueue::GetQueue( )
{
if (rearfront) throw “下溢”;
i=(front+1) % QueueSize;
return data[i];
}
循环队列的实现——队列长度
template
int CirQueue::GetLength( )
{
if (rearfront) throw “下溢”;
len=(rear-front+ QueueSize) % QueueSize;
return len;
}
链队列类的声明
template
class LinkQueue
{
public:
LinkQueue( );
~LinkQueue( );
void EnQueue(T x);
T DeQueue( );
T GetQueue( )；
bool Empty( )；
private:
Node *front, *rear;
};
链队列的实现——出队
template
T LinkQueue::DeQueue( )
{
if (rearfront) throw “下溢”;
p=front->next;
x=p->data;
front->next=p->next;
delete p;
if (front->next==NULL) rear=front;
return x;
}