数据结构——栈和队列（特殊线性表）
栈和队列
- 一、栈
- 栈的逻辑结构
- 栈的抽象数据类型定义
- 1.栈的顺序存储结构及实现
- 顺序栈类的声明
- 顺序栈的实现——入栈
- 顺序栈的实现—判断是否是空栈
- 顺序栈的实现——取栈顶
- 顺序栈的实现——出栈
- 两栈共享空间(双端栈)
- 两栈共享空间类的声明
- 两栈共享空间的实现——插入
- 两栈共享空间的实现——删除
- 判断某个栈空算法
- 取某个栈栈顶的算法
- 2.栈的链接存储结构及实现
- 链栈的类声明
- 链栈的实现——插入（入栈）
- 链栈的实现——删除（出栈）
- 链栈的实现——链栈的析构（链栈的销毁）
- 3.顺序栈和链栈的比较
- 4.栈的应用——括号匹配的检验
- 二、队列
- 队列的逻辑结构
- 队列的抽象数据类型定义
- 1.队列的顺序存储结构及实现
- 循环队列类的声明
- 循环队列的实现——入队
- 循环队列的实现——出队
- 循环队列的实现——读队头元素
- 循环队列的实现——队列长度
- 2.队列的链接存储结构及实现
- 链队列类的声明
- 链队列的实现——构造函数
- 链队列的实现——入队
- 链队列的实现——出队
- 3.循环队列和链队列的比较
- 三、特殊线性表小结
一、栈
栈的逻辑结构
栈：限定仅在表尾进行插入和删除操作的线性表。
空栈：不含任何数据元素的栈。
允许插入和删除的一端称为栈顶，另一端称为栈底。
注意：栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。
栈的抽象数据类型定义
1.栈的顺序存储结构及实现
顺序栈类的声明
const int MAX_SIZE=100;
template <class T>
class seqStack
{
public:
seqStack ( ) ;
~seqStack ( );
void Push ( T x );
T Pop ( );
T GetTop ( );
bool Empty ( );
private:
T data[MAX_SIZE];
int top;
}
顺序栈的实现——入栈
void seqStack<T>::Push ( T x)
{
if (top==MAX_SIZE-1) throw “溢出”;
top++;
data[top]=x;
}
顺序栈的实现—判断是否是空栈
template <class T>
bool seqStack<T>::Empty ()
{
if (top==-1)
return true;
return false;
}
顺序栈的实现——取栈顶
template <class T>
T seqStack<T>::GetTop ( )
{
if (Empty()) throw ”空栈” ；
return data[top];
}
顺序栈的实现——出栈
template <class T>
T seqStack<T>:: Pop ( )
{
if (top==-1) throw “溢出”;
x=data[top];
top--;
return x;
}
两栈共享空间(双端栈)
两栈共享空间类的声明
const int Stack_Size=100;
template <class T>
class BothStack
{
public:
BothStack( );
~BothStack( );
void Push(int i, T x);
T Pop(int i);
T GetTop(int i);
bool Empty(int i);
private:
T data[Stack_Size];
int top1, top2;
};
两栈共享空间的实现——插入
template <class T>
void BothStack<T>::Push(int i, T x )
{
if (top1==top2-1)
throw "上溢";
if (i==1)
data[++top1]=x;
if (i==2)
data[--top2]=x;
}
两栈共享空间的实现——删除
template <class T>
T BothStack<T>::Pop(int i){
if (i==1) {
if (top1== -1) throw "下溢";
return data[top1--];
}
if (i==2) {
if (top2==StackSize) throw "下溢";
return data[top2++];
}
}
判断某个栈空算法
template <class T>
bool BothStack<T>::Empty(int i)
{
if(i==1){
if(top1==-1) return 1;
else return 0;
}
if(i==2) {
if(top2==StackSize) return 1;
else return 0;
}
}
取某个栈栈顶的算法
template <class T>
T BothStack<T>::GetTop(int i)
{
if(i==1) {
if (top1!=-1) return data[top1];
}
if(i==2) {
if(top2!=StackSize) return data[top2];
}
}
2.栈的链接存储结构及实现
链栈的类声明
template <class T>
class LinkStack
{
public:
LinkStack( ) {top=NULL;};
~LinkStack( );
void Push(T x);
T Pop( );
T GetTop( );
bool Empty( );
private:
Node<T> *top;
}
链栈的实现——插入（入栈）
链栈的实现——删除（出栈）
链栈的实现——链栈的析构（链栈的销毁）
3.顺序栈和链栈的比较
4.栈的应用——括号匹配的检验
代码实现
#include 二、队列
队列的逻辑结构
队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。
空队列：不含任何数据元素的队列。
允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。
队列的抽象数据类型定义
1.队列的顺序存储结构及实现
循环队列类的声明
const int QueueSize=100;
template <class T>
class CirQueue{
public:
CirQueue( )；
~ CirQueue( )；
void EnQueue(T x);
T DeQueue( );
T GetQueue( );
bool Empty( ){
if (rear==front) return true;
return false;
}；
private:
T data[QueueSize];
int front, rear;
};
循环队列的实现——入队
template <class T>
void CirQueue<T>::EnQueue(T x)
{
if ((rear+1) % QueueSize ==front) throw "上溢";
rear=(rear+1) % QueueSize;
data[rear]=x;
}
循环队列的实现——出队
template <class T>
T CirQueue<T>::DeQueue( )
{
if (rear==front) throw "下溢";
front=(front+1) % QueueSize;
return data[front];
}
循环队列的实现——读队头元素
template <class T>
T CirQueue<T>::GetQueue( )
{
if (rear==front) throw "下溢";
i=(front+1) % QueueSize;
return data[i];
}
循环队列的实现——队列长度
template <class T>
int CirQueue<T>::GetLength( )
{
if (rear==front) throw "下溢";
len=(rear-front+ QueueSize) % QueueSize;
return len;
}
2.队列的链接存储结构及实现
链队列：队列的链接存储结构
队头指针即为链表的头指针
链队列类的声明
template <class T>
class LinkQueue
{
public:
LinkQueue( );
~LinkQueue( );
void EnQueue(T x);
T DeQueue( );
T GetQueue( )；
bool Empty( )；
private:
Node<T> *front, *rear;
};
链队列的实现——构造函数
template <class T>
LinkQueue<T>::LinkQueue( )
{
front=new Node<T>;
front->next=NULL;
rear=front;
}
链队列的实现——入队
template <class T>
void LinkQueue<T>::EnQueue(T x)
{
s=new Node<T>;
s->data=x;
s->next=NULL;
rear->next=s;
rear=s;
}
链队列的实现——出队
template <class T>
T LinkQueue<T>::DeQueue( )
{
if (rear==front) throw "下溢";
p=front->next;
x=p->data;
front->next=p->next;
delete p;
if (front->next==NULL) rear=front;
return x;
}
3.循环队列和链队列的比较
时间性能:
循环队列和链队列的基本操作都需要常数时间O (1)。
空间性能:
循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。
链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。
三、特殊线性表小结
