数据结构第三章

栈是限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的一端称为栈顶，另一端称为栈底。

  不含任何数据元素的栈称为空栈。

  栈还有后进先出的特性。

  栈的顺序存储结构称为顺序栈。

  顺序栈的类的声明

const int  MAX_SIZE=100;

template <class DataType>

class seqStack

{

   public:

       seqStack ( ) ;

       ~seqStack ( );

       void  Push ( DataType  x );

       DataType   Pop ( );

       DataType   GetTop ( );

       bool  Empty ( );

   private:

       DataType  data[MAX_SIZE];

       int  top;

}

入栈

  template<class DataType>

void seqStack<DataType> ::Push ( DataType  x)

{

    if (top == MAX_SIZE-1)  throw  “溢出”;

    top++;

    data[top] = x;

 }

  出栈

template <class  DataType>

DataType seqStack<DataType> :: Pop ( )

{

    if (top == -1)  throw  “溢出”;

    x = data[top--];

    return  x;

}

两栈共享空间的类的声明

const int Stack_Size=100; 

template <class DataType>

class BothStack

{

 public:

      BothStack( );

      ~BothStack( );

      void Push(int i, DataType x);  

      DataType Pop(int i);         

      DataType GetTop(int i);      

      bool Empty(int i);    

  private:

      DataType data[Stack_Size];    

      int top1, top2;       

};

 

  栈的链接存储结构称为链栈。

链栈的类的声明

template <class DataType>

class LinkStack

{   

  public:

        LinkStack( );

        ~LinkStack( );           

        void Push(DataType x);

        DataType Pop( );

        DataType GetTop( );

        bool Empty( );

  private:

        Node<DataType> *top;

}

插入

template <class DataType>

void LinkStack<DataType> ::Push(DataType x)

{

   s = new Node<DataType>;

   s->data = x;

   s->next = top;

  top = s;

}

 

  队列是只允许在一端进行插入操作，另一端进行删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。

队空和队满的判定方法

方法一：附设一个存储队列中元素个数的变量num，当num=0时队空，当num=QueueSize时为队满；

方法二：修改队满条件，浪费一个元素空间，队满时数组中只有一个空闲单元；

方法三：设置标志flag，当front=rear且flag=0时为队空，当front=rear且flag=1时为队满。

  队列的首尾相接的顺序存储结构称为循环队列。

循环队列的类的声明

const int QueueSize=100;

template <class DataType>   

class CirQueue

{

 public:

     CirQueue( )；

     ~ CirQueue( )；

     void EnQueue(DataType x);

    DataType DeQueue( );            

    DataType GetQueue( );

    bool Empty( )；

 private:

    DataType data[QueueSize];  

    int front, rear;

};

入队

const int QueueSize=100;

template <class DataType>   

class CirQueue

{

 public:

     CirQueue( )；

     ~ CirQueue( )；

     void EnQueue(DataType x);

    DataType DeQueue( );            

    DataType GetQueue( );

    bool Empty( )；

 private:

    DataType data[QueueSize];  

    int front, rear;

};

出队

template <class DataType>

DataType CirQueue<DataType> ::DeQueue( )

{

    if (rear == front) throw "下溢";

    front = (front + 1) % QueueSize;

    return data[front];

}

读取队头元素

template <class DataType>

DataType CirQueue<DataType> ::GetQueue( )

{

   if (rear == front) throw "下溢";

   i = (front + 1) % QueueSize; 

   return data[i];

}

链队列类的声明

template <class DataType>

class LinkQueue

{  

 public:

     LinkQueue( );    

     ~LinkQueue( );

     void EnQueue(DataType x);

     DataType DeQueue( );      

     DataType GetQueue( )；

     bool Empty( )；

 private:

     Node<DataType> *front, *rear;

};

构造函数

template <class DataType>

class LinkQueue

{  

 public:

     LinkQueue( );    

     ~LinkQueue( );

     void EnQueue(DataType x);

     DataType DeQueue( );      

     DataType GetQueue( )；

     bool Empty( )；

 private:

     Node<DataType> *front,*rear;

};

入队

template <class DataType>

void LinkQueue<DataType> ::EnQueue(DataType x)

{

   s = new Node<DataType>;

   s->data = x;

   s->next = NULL;

   rear->next = s;

   rear = s;

}

出队

template <class DataType>

DataType LinkQueue<DataType> ::DeQueue( )

{

    if (rear == front) throw "下溢";

    p = front->next;

    x = p->data;

    front->next = p->next;       

    if (p->next == NULL)  rear =front;  

    delete p;

    return x;

}