第3章 栈和队列

栈
定义：限定仅在表的一端进行插入和删除操作的线性表，允许插入和删除的一端称为栈顶，另一端称为栈底。
栈的特性：后进先出（first in,last out)
Operation:
InitStack // 栈的初始化
DestroyStack//栈的销毁
Push//入栈
GetTop//出栈
Empty//判断栈是否为空
顺序栈的实现
const int StackSize=10;
template
class SeqStack
{
public:
SeqStack();
~SeqStack();
void Push(T x);
T Pop();
T GetTop();
int Empty();
private:
T data[StackSize];
int top;
};
入栈
template
void SeqStack::Push(T x)
{
if(topStackSize-1) throw"上溢";
data[++top]=x;
}
出栈
template
T SeqStack::Pop()
{
T x;
if(top-1) throw"下溢";
x=data[top–];
return x;
}
取栈顶元素
template
T SeqStack::GetPop()
{
T x;
x=data[top];
return x;
}
判空
template
int SeqStack::Empty()
{
int a=0;
if(top==-1) a=1;
return a;
}
链栈就是运用链接存储结构
template
class LinkStack
{
public:
LinkStack();
~LinkStack();
void Push(T x);
T Pop();
T GetTop();
int Empty();
private:
Node *top;
};
入栈
template
void LinkStack::Push(T X)
{
Node *s=NULL;
s=new Node;
s->data=x;
s->next=top;
top=s;
}
出栈
template
T LinkStack::Pop()
{
Node *p=NULL;
T x;
if(topNULL) throw"下溢"；
x=top->data;
p=top;
top=top->next;
delete p;
return x;
}
取栈顶元素
template
T LinkStack::GetPop()
{
T x;
x=top->data;
return x;
}
判空
template
int LinkStack::Empty()
{ int a=0;
if(topNULL) a=1;
return a;
}
顺序栈和链栈基本操作的时间复杂度都为O（1），当栈元素个数变化比较大时用链栈，变化比较小时用顺序栈。
队列
定义：只允许在一端进行插入操作，在另一端进行删除的线性表。
允许插入的一端为队尾，允许删除的一端为队头。
特点：先进先出（first in,first out)
const int QueueSize=100;
template
class CirQueue
{
public:
CirQueue();
~CirQueue();
void EnQueue(T X);
T DeQueue();
T GetQueue();
int Empty();
private:
T data[QueueSize];
int front,rare;
}
入队
template
void CirQueue::EnQueue(T x)
{
if((rare+1)%QueueSizefront) throw “上溢”;
rare=(rare+1)%QueueSize;
data[rare]=x;
}
出队
template
T CirQueue::DeQueue()
{
if(rarefront) throw"下溢";
front=(front+1)%QueueSize;
return data[front];
}
取队头元素
template
T CirQueue::GetQueue()
{
if(rarefront) throw"下溢";
return data[(front+1)%QueueSize];
}
判空
template
int CirQueue::Empty()
{
int a=0;
if(rare=front) a=1;
return a;
}
链队列
template
class LinkQueue
{
public:
LinkQueue();
~LinkQueue();
void EnQueue(T X);
T DeQueue();
T GetQueue();
int Empty();
private:
Node *front,*rare;
}
构造函数
template
LinkQueue::LInkQueue()
{
Node*s=NULL;
s=new Node;
s->next=NULL;
front=rare=s;
}
入队
template
void LinkQueue::EnQueue(T x)
{
Node*s=NULL;
s=new Node;
s->data=x;
s->next=NULL;
rare->next=s;
rare=s;
}
出队
template
T LinkQueue::DeQueue()
{
T x;
Node*p=NULL;
if(rare=front) throw"下溢";
p=front->next;
x=p->data;
front->next=p->next;
if(p->nextNULL) rare=front;
delete p;
return x;
}
循环队列和链队列基本操作的时间复杂度为O（1）,当队列中元素比较少时用循环队列，元素比较多时用链队列，如果确定不会发生假溢出时也可以用顺序队列。
栈和队列是特殊的链表，学好要多做题多练。