数据结构——栈和队列(特殊线性表)

数据结构 专栏收录该内容
12 篇文章 0 订阅

一、栈

栈的逻辑结构

:限定仅在表尾进行插入和删除操作的线性表。
空栈:不含任何数据元素的栈。
允许插入和删除的一端称为栈顶,另一端称为栈底
在这里插入图片描述
注意:栈只是对表插入和删除操作的位置进行了限制,并没有限定插入和删除操作进行的时间。

栈的抽象数据类型定义

在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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 <stack>
using namespace std; 
void match(stack<char> &s,char ch[]) {
        char e; 
        for(int i=0;ch[i]!=NULL;i++) {
	switch(ch[i]) {
	 case '(': 
	 case '[':
	 case '{':
		 s.push(ch[i]); break; 
	
    case ')':
    case ']':
    case '}': 
        if(s.empty()) 
  	         cout<<"Extra right brackets\n"; return ; 
        else { 
	      e=s.top(); 
             if(ch[i]==')' && e=='(' ||ch[i]==']' && e=='[' ||ch[i]=='}' && e=='{' ) { 
                     s.pop(); break; }
            else { cout<<"Brackets not match\n"; return; }
        }
     }
  }
   if(s.empty()) 
        cout<<"Brackets match\n"; 
   else cout<<"Extra left brackets\n"; 
} 

二、队列

队列的逻辑结构

队列:只允许在一端进行插入操作,而另一端进行删除操作的线性表。
空队列:不含任何数据元素的队列。
允许插入(也称入队、进队)的一端称为队尾,允许删除(也称出队)的一端称为队头
在这里插入图片描述

队列的抽象数据类型定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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)。
空间性能:
循环队列:必须预先确定一个固定的长度,所以有存储元素个数的限制和空间浪费的问题。
链队列:没有队列满的问题,只有当内存没有可用空间时才会出现队列满,但是每个元素都需要一个指针域,从而产生了结构性开销。

三、特殊线性表小结

在这里插入图片描述

  • 0
    点赞
  • 0
    评论
  • 3
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 1024 设计师:白松林 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值