您的位置：首页 > 其它

第三章 栈和队列

2014-11-18 13:02 183 查看
 
 
第三章  
栈和队列
一．栈
1.栈：限定仅在表尾进行插入和删除操作的线性表（允许插入和删除的一端称为栈顶;另一端称为栈底）。
2.空栈：不含任何数据元素的栈。
3.在任何时候出栈的元素都只能是栈顶元素，即最后入栈者最先出栈，具有后进先出的特性。
4.栈的抽象数据类型定义：
（1）Push（输入：元素值x；输出：如果插入不成功，则抛出异常）功能：入栈操作，在栈顶插入一个元素x。
（2）Pop（输入：无；输出：如果删除成功，返回被删元素值，否则抛出异常）功能：出栈操作，删除栈顶元素。
（3）GetTop（输入：无；输出：若栈不空，返回当前的栈顶元素值）功能：取栈顶元素，读取当前的栈顶元素。
（4）Empty（输入：无；输出：如果栈为空，返回1，否则返回0）功能：判空操作，判断栈是否为空。
 
5.(1)顺序栈的实现：
模板：
Const int stacksize=10;
Template<class dt>
Class seqstack
{

 public:

     
seqstack();

     
~seqstack(){}

     
void Push(dt x);

     
dt Pop();

     
dt GetTop();

     
int Empty();

     
private:

            
dt data[stacksize];

            
int top;

};
 
(2).顺序栈：
（1）入栈算法Push：
Template<class dt>
Void seqstack<dt>::Push(dt x)
{
If(top==stacksize-1)throw “上溢”;
Data[++top]=x;
}
(2)出栈算法Pop:
Template<class dt>
Dt seqstack<dt>::Pop()           

{
If(top==-1)throw “下溢”;
X=data[top--];
Return x;
}
6.链栈：
（1）入栈算法Push:
Template<class dt>
Void linkstack<dt>::Push(dt x)
{
S=new Node;s->data=x;s->next=top;top=s;
}                           

(2)出栈算法Pop:
Template<class dt>
Dt linkstack<dt>::Pop()
{
If(top==NULL)throw “下溢”;
X=top->data;p=top;
Top=top->next;delete p;return x;
}
二．队列
1.队列：只允许在一端进行插入操作，在另一端进行删除操作的线性表。
2.队列中的元素具有先进先出的特性。
3.队列的抽象数据类型定义
（1）EnQueue(输入：元素值x；输出：如果插入不成功，则抛出异常)功能：入队操作，在对尾插入一个元素。
（2）DeQueue(输入：无；输出：如果删除成功，返回被删元素值，否则，抛出删除异常)
功能：出队操作，删除队头元素。
（3）GetQueue(输入：无；输出：若队列不空，返回队头元素)功能：读取队头元素。
（5）Empty(输入：无；输出：如果队列为空，返回1，否则返回0）功能：判空操作，判断队列是否为空。
4.(1)模板：
Const int Queuesize=100;
Template<class Data Type>
Class cirQueue
{
Public:
cirQueue(){front=rear=Queuesize-1;}
~cirQueue(){}
Void EnQueue(Data Typex);
Dt DeQueue();
De GetQueue();
Int Empty(){front==rear?return 1:return 0;}
Private:
Dt data[Queuesize];
Int front,rear;
};
(2)循环队列：
（1）入队算法EnQueue：
template<class Data Type>
void cirQueue<Data Type>::EnQueue(Data Typex)
{
if((rear+1)%Queuesize==front)throw “上溢”;
rear=(rear+1)%Queuesize;
data[rear]=x;
}
(2)出队算法DeQueue:
template<class Data Type>
dt cirQueue<Data Type>::DeQueue()
{
Ii(rear==front)throw “下溢”;
front=(front+1)%Queuesize;
return data[front];
}
(3)读取队头元素算法GetQueue:
template<class Data Type>
dt cirQueue<Data Type>::GetQueue()
{
if(rear==front)throw “下溢”;
i=(front+1)%Queuesize;
return data[i];
}
5.链队列
（1）构造函数算法linkQueue：
template<class Data Type>
linkQueue<Data Type>::linkQueue()
{
s=new Node; s->next=NULL;front=rear=s;
}
(2)入队算法EnQueue：
template<class Data Type>
void linkQueue<Data Type>::EnQueue(Data Typex)
{
s=new Node;s->data=x;
s->next=NULL;rear->next=s;
rear=s;
}
(3)出队算法DeQueue：
template<class Data Type >
dt linkQueue<Data Type>::DeQueue()
{
if(rear==front)throw “下溢”;
p=front->next;x=p->next;
front->next=p->next;
if(p->next==NULL) rear=front;
delete=p;return x;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航