数据结构总结（4）

队列和栈

{

  队列：

    顺序存储队列和链式存储队列

  栈：

    顺序存储栈和链式存储栈

}

队列

{

  队列的定义：

     只能在表的一端（队尾）进行插入，在另一端（队头）进行删除运算的线性表

  顺序存储队列

  {

顺序存储队列的表示：

 

顺序存储队列的实现（一般采用循环队列）

{

  顺序队列的定义：

  #define MAXQSIZE  100  //最大长度

  Typedef struct 

  {

   QElemType *base;  //初始化的动态分配存储空间

   int  front;            //头指针   

   int  rear;             //尾指针

  }SqQueue; 

 顺序队列的重要操作的实现：

 （1）队列的初始化

      Status InitQueue(SqQueue &Q)

      {

        Q.base=new ElemType[MAXSIZE];    //为队列分配空间

        If(!Q.base) return false;     //分配空间失败

        front=rear=0;         //设置为空队列

        Return ture;              //初始化成功         

             

      } 

    （2）求队列的长度

         int QueueLength(SqQueue Q)

         {

            return (Q.rear-Q.font+MAXSIZE)%MAXSIZE;  //返回队列的长度

         }

   （3）循环队列入队

        Status EnQueue(SqQueue &Q,ElemType e)

        {

           If((Q.rear-Q.front+MAXSIZE)%MAXSIZE==MAXSIZE-1) return false；

           //堆满，入队失败

           Q.base[rear]=e;        //插入队列的尾部

           Q.rear=(Q.rear+1)%MAXSIZE; //队尾指针上移

           return ture;         //入队成功

        } 

   （4）顺序队列出队

        Status DeQueue(SqQueue &Q,ElemType e)

        {

          If(Q.rear==Q.front) return false;    //空队

          e=Q.base[front];     //出队

          front=(front+1)%MAXSIZE;       //修改队头指针

          return ture;                   //出队成功        

        } 

  } 

  链式存储队列

  {

链式存储队列的表示：

 

链式存储队列实现：

typedef struct QNode{

   ElemType   data;

   struct Qnode  *next;

}Qnode, *QueuePtr;

typedef struct {

   QueuePtr  front;            //队头指针   

   QueuePtr  rear;             //队尾指针

}LinkQueue;  

链队的重要操作的实现：

（1）链队的初始化

     Status IniQueue(LinkQueue &Q)

     {

       Q.front=Q.rear=QueuePtr=new Struct QNode  //初始化为空队

       If(!Q.front)return false;      //分配空间失败

       Q.front->next=NULL;        //

       Return OK;                 //分配成功 

     }

（2）摧毁队列

         Status DestroyQueue(LinkQueue &Q)

         {

            while(Q.front)                //队列非空

            {Q.rear=Q.front->next; delete Q.front;Q.front=Q.rear;}  

           //删除队头元素，借助队尾指针前移动

            return ture;

         } 

（3）判断链队列是否为空

     Status IsEmpty_Queue(LinkQueue Q)

     {

       if(Q.rear==Q.front) return ture;

       else return false;

     }

（4）求链队列的队头元素

     Status GetHead(LinkQueue Q,ElemType &e)

     {

       if(Q.rear==Q.front) return false;   //队空

       e=Q.front->next->data;          //取出队头元素 

       return ture;          

     }

（5）链队列入队

     Status EnQueue(LinkQueue Q,ElemType &e)

     {

       Q.rear->next=new QNode;     //队尾指针指向新结点

       if（Q.rear->next）return false;      //入队成功

       Q.rear->next->data=e;Q.rear->next->next=NULL;

       Q.rear=Q.rear->next;

       return true;

     }

 （6）链队列出队

     Status DeQueue(LinkQueue &Q,ElemType &e)

     {

       p=Q.front->next ;

       if(Q.front==Q.rear) reture false;

       e=p->data;

       Q.front->next=p->next;

       if(Q.rear==p)

       Q.rear=Q.front;

       delete p;

       return ture;

     }

 

 

  } 

  

}

栈

{

   栈的定义：

     只能在表的一端（栈顶）进行插入和删除运算的线性表

   栈的表示： 

    

   顺序存储栈

   {

     顺序存储栈的表示：

     

      顺序存储栈的实现

      {

       顺序栈的类型定义：

            #define  MAXSIZE  100

            typedef struct

            {

             ElemType   *base;

             ElemType   *top;

             int stacksize;

            }SqStack;

       顺序栈的重要操作的实现：

       （1）顺序栈的初始化

            Status InitStack(SqStack &S)

            {

              S.base=new ElemType[MAXSIZE];

              if(!S.base) return false;

              S.top=S.base;

              S.stacksize=MAXSIZE;

              return ture;

            }

       （2）判断顺序栈是否为空

            bool StackEmpty(Sqstack S)

            {

              return(S.base==S.top);

            }

       （3）求顺序栈的长度

            int StackLength(SqStack S)

            { 

              return (S.base-S.top);

            }  

       （4）清空顺序栈

            Status ClearStack(SqStack &S)

            {

               if(S.base)S.top=S.base;

               return ture;

            }  

       （5）摧毁顺序栈

            Status DestroryStack(SqStack &S)

            {

               if(S.base)

               {

                  delete []S.base;

                  S.stacksize=0;

                  S.base=S.top=NULL;

               } 

               return ture;

            }

        （6）顺序栈入栈

             Status Push(SqStack &S,ElemType &e)

              {

                 if(S.top-S.base==S.stcaksize) return false;

                 *S.top++ =e;return ture;

              }

          （7）顺序栈出栈

               Status Pop(SqStack &S,ElemType &e)

               {

                  if(S.top==S.base) return false;

                  e=*--S.top;

                  return ture;

               } 

          （8）取顺序栈栈顶元素

               Status GetTop(SqStack &S,ElemType &e)

               {

                  if(S.base==S.top) return false;

                  e=*(S.top-1);

                  return ture;

               } 

            

       

     

   }

   链式存储栈

   {

     链式存储栈的表示：

 

     链式存储栈的实现

     {

        链栈的类型定义：

            typedef  struct StackNode {

            ElemType  data;

            struct StackNode *next;

            } StackNode,  *LinkStack;

            LinkStack S;    

        链栈的重要操作的实现：

        （1）链栈的初始化

             Status InitStack(LinkStack &S)

             {

                S=NULL;

             }

        （2）判断链栈是否为空

             Status StackEmpty(LinkStack S)

             {

               if(!S)return false;

               else return ture; 

             }

        （3）链栈进栈

             Status Push(LinkStack &S,ElemType &e)

             {

               p=new StackNode;

               if(!p) return fasle;

               p->data=e;p->next=S;S=p;

               return ture;

             }  

        （4）链栈出栈

             Status Pop(LinkStack &S,ElemType &e)

             {

               if(!S)return false;

               e=S->data;p=S->next;delete S;S=p;

               return ture;

             }

        （5）取链栈栈顶元素

             ElemType GetTop(LinkStack &S)

             {

               if(!S) return false;

               else return S->data;

             }

     }

   }

   栈的应用：

     递归与递归算法

     以下三种情况常常用到递归方法（分治法）：

      （1）递归定义的数学函数

      （2）具有递归特性的数据结构（树和广义表）

      （3）可递归求解的问题

 

   }