队列的顺序存储和链式表示方法-数据结构学习笔记2.3

1，顺序存储时我们常用循环队列，为了区分队列满和空，我们最多只用MAX-1个空间

队列空：q->rear=q->front

队列满:q->front=(q->rear+1)%MAX

    typedef int Position;
    struct QNode {
        ElementType *Data;     /* 存储元素的数组 */
        Position Front, Rear;  /* 队列的头、尾指针 */
        int MaxSize;           /* 队列最大容量 */
    };
    typedef struct QNode *Queue;
     
    Queue CreateQueue( int MaxSize )
    {
        Queue Q = (Queue)malloc(sizeof(struct QNode));
        Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
        Q->Front = Q->Rear = 0;
        Q->MaxSize = MaxSize;
        return Q;
    }
     
    bool IsFull( Queue Q )
    {
        return ((Q->Rear+1)%Q->MaxSize == Q->Front);
    }
     
    bool AddQ( Queue Q, ElementType X )
    {
        if ( IsFull(Q) ) {
            printf("队列满");
            return false;
        }
        else {
            Q->Rear = (Q->Rear+1)%Q->MaxSize;
            Q->Data[Q->Rear] = X;
            return true;
        }
    }
     
    bool IsEmpty( Queue Q )
    {
        return (Q->Front == Q->Rear);
    }
     
    ElementType DeleteQ( Queue Q )
    {
        if ( IsEmpty(Q) ) { 
            printf("队列空");
            return ERROR;
        }
        else  {
            Q->Front =(Q->Front+1)%Q->MaxSize;
            return  Q->Data[Q->Front];
        }
    }

2,链式表示,因为线性表的头指针上插入删除都放便所以我们删除操作在头指针，尾指针负责插入操作！

带头结点

  #include<stdio.h>
#include <stdlib.h>
#define bool int
#define true 1
#define false 0
typedef int ElementType ;
const ElementType ERROR=-1;
typedef struct Node *PtrToNode;  
 struct Node { /* 队列中的结点 */  
     ElementType Data;  
     PtrToNode Next;  
 };  
 typedef PtrToNode Position;  
 
 struct QNode {  
     Position Front, Rear;  /* 队列的头、尾指针 */  
     int MaxSize;           /* 队列最大容量 */  
 };  
 typedef struct QNode *Queue;  
 Queue Creaequeue(){  
 Queue q=(Queue)malloc(sizeof(struct QNode));  
 PtrToNode lnode=(PtrToNode)malloc(sizeof(struct Node));  
 lnode->Next=NULL;  
 q->Rear=q->Front=lnode;  
       
  return  q;  
 }  
 bool  IsEmpty( Queue Q )  
 {  
     return ( Q->Front->Next == NULL);  
 }  
    
 ElementType DeleteQ( Queue Q )  
 {  
     Position FirstCell;   
     ElementType FirstElem;  
        
     if  ( IsEmpty(Q) ) {  
         printf("队列空");  
         return ERROR;  
     }  
     else {  
         FirstCell = Q->Front->Next;              
          Q->Front = FirstCell->Next;  
         FirstElem = FirstCell->Data;  
    
         free( FirstCell );  /* 释放被删除结点空间  */  
         return  FirstElem;  
     }  
 }  

不带头结点

 


    typedef struct Node *PtrToNode;
    struct Node { /* 队列中的结点 */
        ElementType Data;
        PtrToNode Next;
    };
    typedef PtrToNode Position;
     
    struct QNode {
        Position Front, Rear;  /* 队列的头、尾指针 */
        int MaxSize;           /* 队列最大容量 */
    };
    typedef struct QNode *Queue;
    Queue Creaequeue(){  
     Queue q=(Queue)malloc(sizeof(struct QNode));  
     q->Rear=q->Front=NULL;         
     return  q;  
      }  
    bool IsEmpty( Queue Q )
    {
        return ( Q->Front == NULL);
    }
     
    ElementType DeleteQ( Queue Q )
    {
        Position FrontCell; 
        ElementType FrontElem;
         
        if  ( IsEmpty(Q) ) {
            printf("队列空");
            return ERROR;
        }
        else {
            FrontCell = Q->Front;
            if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */
                Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */
            else                     
                Q->Front = FrontCell->Next;
            FrontElem = FrontCell->Data;
     
            free( FrontCell );  /* 释放被删除结点空间  */
            return  FrontElem;
        }
    }