数据结构——栈和队列

栈的逻辑结构：栈是限定仅在表头和表尾进行插入和删除操作的线性表
允许插入的一端称为栈顶，另一端为栈底
栈的代码实现：
首先我们先考虑一下顺序存储结构的栈

#include<iostream>
const int Maxsize=100;
using namespace std;
template <class T>
class seqStack
{
	private:
		T data[Maxsize];
		int top;
	public:
		seqStack();//构造函数
		~seqStack();//析构函数
		void Push(T x);//入栈
		T pop();//出栈
		T GetTop();//取栈顶
		bool Empty();//判断栈是否为空
	
};
template <class T>
void seqStack<T>::Push(T x)
{
	if(top=Maxsize) throw"溢出";//如果top=Maxsize的话栈满，那么抛出错误
	top++;//否则栈顶元素后移
	data[top]=x;//将x的值入栈
}
template <class T>
bool seqStack<T>::Empty()//判断栈是否为空返回为真，否则返回假
{
	if(top==-1)
		return true;
	else
		return false;
}
template<class T>//取栈顶函数，返回栈顶的值
T seqStack<T>::GetTop()
{
	if(Empty()) throw "Empty STCAK";
	else
		return data[top];
}
template<class T>
T seqStack<T>::pop()//出栈操作
{
	if(top=-1)
		throw"溢出";
	else
		{
		return data[top];//返回栈顶的值
		top--;//栈顶前移
		}	
}
int main()
{
	
	return 0;
}

双端栈

#include<iostream>
using namespace std;
const int Stack_size=100;//建立俩栈共用数组空间大小
template<class T>
class BothStack
{
public:
	BothStack();
	~BothStack();
	void Push(int i,T x);//插入函数
	T Pop(int i);
	T GetPop(int i);
	bool Empty(int i);
private:
	T data[Stcak_size];
	int top1,top2;
}；
/*插入函数如果栈满则抛出异常；
  判断是插在栈1还是栈2
  若插在栈1则
	top1+1；
	top1处填入x；
	若插入在栈2
	则top2+1；
	top2处填入x；
	函数实现：*/
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;
}
/*删除函数Pop
若是在栈1中删除，则若栈1为空栈，则抛出异常
删除并返回栈1栈顶元素
若是在栈2中删除，则若栈2为空栈，则抛出异常
删除并返回栈2的栈顶元素*/
template<class T>
T BothStack<T>::Pop(int i)
{
if(i==1)
{
if(top1==-1)
{
throw"下溢";
return data[top1--];
}
if(i==2)
{
if(top2==Stack_size)
throw "下溢";
return data[top2++];
}
}
/*判断某个栈空算法*/
template<class T>
bool BothStack<T>::Empty(int i)
{
if(i==1)
{
if(top==-1)
return 1;
else return 0;
}
if(i==2)
{
if(top2==Stack_size)
return 1;
else 
return 0;
}
}
/*取栈顶元素的算法*/
template<class T>
T BothStack<T>::GetPop(int i)
{
if(i==1)
{
	if(top1!=-1)
	return data[top1];
}
if(i==2)
{
if(top2!=Stack_size)
return data[top2];
}
}
int main()
{
return 0;
}

链栈

栈的链式存储结构实现

```cpp
#include<iostream>
using namespace std;
template <typename T>
struct Node
{
	int data;
	Node <T> *next;
}; 
template<class T>
class LinkStack
{
private:
	Node <T>*top;
public:
	LinkStack(){top=NULL;}
	~LinkStack();
	void Push(T x);
	T Pop();
	T GetTop();
	bool Empty();
};
typename <class T>
void LinkStack<T>::Push()
{
	Node<T> *s;
	s=new Node<T>;
	s->data=x;
	s->next=top;
	top=s;
}
template<class T>
T LinkStack<T>::Pop()
{  
	T x;
	Node *p;
	if(top==NULL)
		throw "Error";
	x=top->data;
	p=top->next;
	delete top;
	top=p;
	return x;
}
template <class T>
LinkStack<T>::~LinkStack()
{
	while(top)
	{
		Node<T>*p;
		p=top->next;
		delete top;
		top=p;
	}
}

顺序栈和链栈的比较
时间性能：
相同都是常数时间O（1）；
空间性能：
顺序栈：有元素个数的限制和空间的浪费问题。
链栈：没有栈满的问题，只有当内存没有可用的空间时才会出现栈满，但是每个元素都需要一个指针域，从而产生了结构性的开销。
结论：当栈的使用过程个数变化较大时，用链栈合适。

队列

队列的逻辑结构
队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。
空队列不含有任何元素。
允许插入的一端称为队尾，允许删除的一端称为队头。
队列的操作特性：先进先出。
队列的抽象数据类型定义
ADT Queue
Data
队列中元素具有相同类型及先进先出的特性，相邻元素具有前驱和后继的关系
Operation
InitQueue
前置条件：队列不存在
输入：无
功能：初始化队列
输出：无
后置条件：创建一个空队列
DeQueue
前置条件：队列已存在
输入：无
功能：删除对头元素
输出：如果删除成功，返回被删元素的值
后置条件：如果删除成功，队头减少一个元素
GetQueue
前置条件：队列已存在
输入：无
功能：读取队头元素
输出：若队列不空，返回队头元素
后置条件：队列不变
Empty
前置条件 ：队列已存在
输入：无
功能：判断队列是否为空
输出：若队列为空返回1，否则返回0；
后置条件 ：队列不变
endADT
设置队头队尾两个指针
队头指针指向队头元素的前一个位置；
队尾指针指向队中最后一个元素；
整个队列向数组下标比较大的方向移动，单向移动。
假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间，这种现象叫做假溢出。

#include<iostream>
using namespace std;
const int QueueSize=100;
template<class T>
class CirQueue
{
	private:
		T data[QueueSize];
		int front,rear;
	public:
		CirQueue();
		~CirQueue();
		void EnQueue(T x);
		T DeQueue();
		T GetQueue();
		bool Empty()
};
bool CirQueue<T>::Empty()
{
	if(rear=front)
		return ture;
	return false;
}
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;
}

链队

#include<iostream>
using namespace std;
const int QueueSize=100;
template<class T>
template<typename T>
struct Node
{
	int data;
	Node *front,*rear;
};
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;
}