数据结构_栈和队列 总结

从前看到一些书中提到有关“栈”的相关知识时有些疑惑——什么是“栈”？当时因为时间紧张，就没有去上网仔细查看，后来竟然完全忘记了这件事。直到现在，课程正式学习到了这一知识点，我才恍然记起。正好趁着这个机会，冲鸭！
一、栈
1.栈是特殊的线性表，限定仅在表尾进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶，另一端称为栈底。
2.空栈：不含任何数据元素的栈。
3.栈的操作特性：后进先出。但是栈只是对插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。
4.利用数组实现栈的顺序存储，先要确定用数组的哪一段表示栈底，附设指针top指示栈顶元素在数组中的位置。
进栈：top+1【先判断是否栈满：top=MAX_SIZE-1】
出站：top-1【先判断是否栈空：top=-1】
5.顺序栈的实现：
1）入栈：

template <class T>
void  seqStack<T>::Push ( T  x)
{
     if (top==MAX_SIZE-1)  throw  “溢出”;
     top++;
     data[top]=x;
 } 

2）判断是否栈空：

template <class T>
bool  seqStack<T>::Empty ()
{
     if (top==-1)  
         return true;
     return false;
 } 

3）取栈顶：

template <class T>
T  seqStack<T>::GetTop ( )
{
     if (Empty()) throw  ”空栈” ；
     return data[top];
 } 

4）出栈

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

6.两栈共享空间：
使用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈底为该数组的末端，两个栈从各自的端点向中间延伸。

top1=-1时，栈1为空；
top2=Stack_Size时栈2为空；
top1=top2-1时栈满。
1）插入

template <class T> 
void BothStack<T>::Push(int i, T x )
{
    if (top1==top2-1) 
    //如果栈满，则抛出上溢异常
		throw "上溢";
	//判断是插在栈1还是栈2
    if (i==1) 
    //若在栈1插入，则top1+1；在top1处填入x
		data[++top1]=x;
    if (i==2) 
    //若在栈2插入，则top2-1，在top2处填入x
		data[--top2]=x;
}

2）删除

template <class T>
T BothStack<T>::Pop(int i){
    if (i==1) {   
    //若在栈1删除
        if (top1== -1) 	throw "下溢";
       //删除并返回栈1的栈顶元素：
        return data[top1--];
    }
    if (i==2) {    
     //若在栈2删除                       
        if (top2==StackSize)  	throw "下溢";
        //删除并返回栈2的栈顶元素：
        return data[top2++]; 
   }
}

3）判断栈空：

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;
    }
}

4）取栈顶

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];
   } 
}

7.栈的链接存储结构


将链头作为栈顶，方便操作，且链栈不需要附设头结点。
链栈没有栈满的问题，只有当内存没有可用空间时才会出现栈满。适宜栈的使用中元素个数变化较大时的情况下使用。
1）插入

template <class T>
void LinkStack<T>::Push(T x)
{
    s=new Node<T>;
    s->data=x; 
    s->next=top; 
   top=s; 
}

2）删除

template <class T>
T LinkStack<T>::Pop( )
{
    if (top==NULL)
     throw "下溢";
    x=top->data; 
    p=top; 
    top=top->next;   
    delete p;
    return x;
}

3）析构

template <class T>
LinkStack<T>::~LinkStack( )
{
	while (top)
	{
		Node<T> *p;
		p=top->next;
        		delete top;
		top=p;
	}
}

8.后缀表达式求值

• 从左到右对后缀表达式字符串进行处理，每次处理一个符号；

• 若遇到数字，入栈； 若遇到运算符，栈顶两个数字出栈，执行运算符所定义的运算，并将运算结果入栈；

• 重复以上的工作，直到表达式结束，此时，栈中的数字代表最终的值。

9.中缀表达式求值

• 设置两个栈： OVS(运算数栈)和OPTR(运算符栈)；
• 自左向右扫描中缀表达式： 遇操作数进OVS， 遇操作符则与OPTR栈顶优先数比较：
  OPTR栈顶<当前操作符, 当前操作符进OPTR栈；
  OPTR栈顶>=当前操作符，OVS栈顶、次顶和OPTR栈顶，退栈形成运算T(i)，T(i)进OVS栈。

10.中缀表达式转化为后缀表达式

• 设置一个运算符栈。从左到右依次对中缀表达式中的每个符号进行处理。
• 如果遇到数字，直接输出；
• 如果遇到“（”，则将其入栈；
• 如果遇到运算符a，如果栈顶符号的优先级。
  低于a的优先级，则入栈；
  否则，栈顶符号出栈，直到栈顶符号的优先级低于a的优先级，此时让a入栈。
  若遇到“）”，则栈顶符号出栈，直到“（”；
  重复以上工作，直到表达式结束，此时，将栈里符号全部出栈。

二、队列
1.队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。
2.空队列：不含任何数据元素的队列。
3.队列操作特性：先进先出。
4.队列的顺序存储结构
1）改造数组实现队列的顺序存储：（通常情况下，队首元素存放在下标为0的一端）
队头指针与队尾指针：

• 队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素
  
• 队头指针指向队列中的第一个元素，队尾指针指向队列中的最后一个元素的后一个位置
  
  2）队列的移动（入队、出队）特点：
  整个队列向数组下标较大的方向移动（单向移动性）
  3）解决假溢出：
  将存储队列的数组头尾相连：
  rear=（rear＋1）% MAXSIZE
  front=(front+1) % MAZSIZE
  5.队列的链接存储结构及其实现
  
  1）构造函数

template <class T>
LinkQueue<T>::LinkQueue( )
{
     front=new Node<T>; 
     front->next=NULL;  
     rear=front;
}

2）入队

template <class T>
void LinkQueue<T>::EnQueue(T x)
{ 
    s=new Node<T>; 
    s->data=x; 
    s->next=NULL;
    rear->next=s; 
    rear=s;
}

3）出队

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;
}