队列基本操作

 

链式存储
typedef int QElemType;
typedef int Status;//具体数据类型具体定义
typedef struct QNode//队列结点结构体
{
    QElemType data;
    QNode *next;
} QNode, *Queueptr;

typedef struct   // 链队列类型
{
    Queueptr  front;  // 队头指针（结构体类型的指针）等价于 QNode *front;
    Queueptr  rear;   // 队尾指针
} LinkQueue;

Status InitQueue (LinkQueue &Q) // 构造一个空队列Q
{
    Q.front = Q.rear = (Queueptr)malloc(sizeof(QNode));
    if (!Q.front) exit (0); //存储分配失败
    Q.front->next = NULL;
    return 1;
}

Status EnQueue (LinkQueue &Q, QElemType e)// 插入元素e为Q的新的队尾元素
{
    p = (Queueptr) malloc (sizeof (QNode));
    if (!p)  exit (0);   //存储分配失败
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;//类似于顺序建立链表的过程
    return 1;
}

Status DeQueue (LinkQueue &Q,   QElemType &e)//若队列不空，则删除Q的队头元素，用 e 返回其值
{
    if (Q.front == Q.rear)  //若队空
        return 0;
    p = Q.front->next;
    e = p->data;
    Q.front->next = p->next;//删除操作
    if (Q.rear == p)//如果是最后一个元素
        Q.rear = Q.front;//删除即队空
    free (p);
    return 1;
}

Status GetHead(LinkQueue Q,QElemType &e)// 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
{
    Queueptr p;
    if(Q.front==Q.rear)//队空
        return 0;
    p=Q.front->next;//取队首元素
    e=p->data;
    return 1;
}

Status QueueEmpty(LinkQueue Q)  // 若Q为空队列，则返回1，否则返回0
{
    if(Q.front==Q.rear)
        return 1;
    else
        return 0;
}

void ClearQueue(LinkQueue &Q) // 将Q清为空队列
{
    Queueptr p, q;
    Q.rear=Q.front;
    p=Q.front->next;
    Q.front->next=NULL;//只留下头结点
    while(p)//依次清空所有元素
    {
        q=p;
        p=p->next;
        free(q);
    }
}

Status DestroyQueue(LinkQueue  &Q)//销毁队列
{
    while(Q.front)
    {
        Q.rear=Q.front->next;//Q.rear指向当前删除结点下一结点
        free(Q.front);
        Q.front=Q.rear; //Q.front指向当前删除结点（队头元素）
        //释放一块内存要做两点：1.释放指向它的指针。2.将该指针指向空
    }
    return 1;
}

int QueueLength(LinkQueue Q)  // 求队列的长度
{
    int i=0;
    Queueptr p;
    p=Q.front;
    while(p!=Q.rear)
    {
        i++;
        p=p->next;
    }
    return i;
}

 

顺序存储（循环队列--解决假溢出问题）

1. 头指针指向队首元素，尾指针指向队尾的下一个位置。(这里的指针可认为是数组下标)
 
2. 为了区分队满与队空，则定义一个存储空间为MAXQSIZE大小的队列只允许存放（MAXQSIZE-1）个数据。
 
3. 判空条件为:if(Q.front == Q.rear) return true;
 
   判满条件为:if((Q.rear+1) % MAXQSIZE==Q.front) return true;
 
4. 循环队列的长度为:(Q.read-Q.front + MAXQSIZE) % MAXQSIZE
 
5. 当删除对头元素或者在对尾插入元素时指针均需向后移动:
  
    (1). Q.rear=(Q.rear+1) % MAXQSIZE;
    (2). Q.front=(Q.front+1) % MAXQSIZE;
   

InitQueue(&Q)//构造一个空队列Q
GetHead(Q, &e)//获取队头元素
EnQueue(&Q, e)//插入队尾元素
DeQueue(&Q, &e)//删除队头元素
DestroyQueue(&Q)//销毁队列
ClearQueue(&Q)//清空队列
QueueEmpty(Q)//判断队列是否为空
QueueLength(Q)//求当前队列长度

 

#define MAXQSIZE  100  //最大队列长度
typedef int QElemType;
typedef int Status;//具体数据类型具体定义
typedef struct
{
    QElemType  *base;  // 初始化的动态分配存储空间
    int  front;  // 头指针，若队列不空，指向队列头元素
    int  rear;  // 尾指针，若队列不空，指向队列尾元素的下一个位置
} SqQueue;

Status InitQueue (SqQueue &Q) // 构造一个空队列Q
{
    Q.base = (ElemType *) malloc (MAXQSIZE *sizeof (ElemType));
    if (!Q.base) exit (0);// 存储分配失败
    Q.front = Q.rear = 0;
    return 1;
}

Status EnQueue(SqQueue &Q, ElemType e)// 插入元素e为Q的新的队尾元素
{
    if ((Q.rear+1) % MAXQSIZE == Q.front)//队列满
        return 0;
    Q.base[Q.rear] = e;//插入队尾元素
    Q.rear = (Q.rear+1) % MAXQSIZE;//尾指针向后移动
    return 1;
}

Status DeQueue (SqQueue &Q, ElemType &e)  // 若队列不空，则删除Q的队头元素，用e返回其值
{
    if (Q.front == Q.rear)  return 0;
    e = Q.base[Q.front];//队首元素
    Q.front = (Q.front+1) % MAXQSIZE;//头指针向后移动
    return 1;
}

Status GetHead (SqQueue &Q, ElemType &e)//取队首元素
{
    if (Q.front == Q.rear)  return 0;
    e = Q.base[Q.front];//队首元素
    return 1;
}
Status QueueEmpty (SqQueue &Q)//判断队是否为空
{
    if (Q.front == Q.rear)
        return 1;
    else
        return 0;
}

void ClearQueue(SqQueue &Q)// 将Q清为空队列
{
    Q.front=Q.rear=0;
}

void DestroyQueue(SqQueue &Q)// 销毁队列Q，Q不再存在
{
    if(Q.base)
        free(Q.base);
    Q.base=NULL;
    Q.front=Q.rear=0;
}

int QueueLength(SqQueue Q)  // 返回Q的元素个数，即队列的长度
{
    return(Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}