数据结构-队列（队列的基本操作）

队列

---

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

---

一、队列的顺序存储结构（循环队列）

循环队列的 长度 计算：

• (rear-frot+MAX_SIZE)%MAX_SIZE

循环队列 满 的条件为：

• (rear+1)%MAX_SIZE == front

宏定义及结构体声明

#define MAX_SIZE 20

typedef enum Status{
    _success_,
    _fail_,
    _full_,
    _empty_
}Status;

typedef int Elemtype;

typedef struct queue
{
    Elemtype data[MAX_SIZE];
/*头指针*/
    int front;
/*尾指针,若队列不为空rear指向队列最后一个元素的下一个位置*/
    int rear;
}Queue,* PtrQueue;

初始化队列(Init)

/****************************************
 * 函数名称：InitQueue(PtrQueue que)
 * 功能描述：初始化一个队列
 * 传入参数：PtrQueue que   待初始化的队列
 * 返回值：_success_   成功
 *        _fail_      失败 
 * 队列：
 *      fort指向对列头部，rear只想最后一个数据的
 *      下一位
 * 队列的模型如下：
 *     frot                      rear
 *       |                        |
 *       v                        v
 *     | a1 | a2 | a3 | a4 | a5 |  |
 *     -----------------------------
 * 下标  0    1    2    3    4   5
***************************************/
Status InitQueue(PtrQueue que)
{
    Status _outcome_ = _fail_;
    int i;
    que -> front = NULL;
    que -> rear = NULL;
    for(i = 0; i< MAX_SIZE; i++)
    {
        que ->data[i] = 0;/*初始化为0*/
    }
    return _outcome_ = _success_;
}

队列尾部插入数据(Insert)

/****************************************
 * 函数名称：InsertQueue(PtrQueue q)
 * 功能描述：队尾插入数据
 * 传入参数：PtrQueue que   传入的队列
 * 返回值：_success_   成功
 *        _fail_      失败 
 *        _full_      队列满
 * 注意：队列满的条件为
 *      (rear+1)%MAX_SIZE == front
 ****************************************/
Status InsertQueue(PtrQueue q,Elemtype e)
{
    Status outcome = _fail_;
    if((q ->rear+1)%MAX_SIZE == q ->front)
    {
        return outcome = _full_;/*满队列*/
    }
    q ->data[q ->rear] = e;
    q ->rear = (q ->rear+1)%MAX_SIZE;/*后移*/
    return outcome = _success_;
}

出队操作(Out)

/****************************************
 * 函数名称：OutQueue(PtrQueue q,Elemtype *e)
 * 功能描述：出队列操作
 * 传入参数：PtrQueue que   传入的队列
 *          ElemType *e    队列出来的数据赋值给*e
 * 返回值：_success_   成功
 *        _fail_      失败 
 *        _empty_      队列满
 ****************************************/
Status OutQueue(PtrQueue q,Elemtype *e)
{
    Status _outcome = _fail_;
    if(q ->front == q ->rear)
    {
        return _outcome = _empty_;/*空队列*/
    }
    *e = q ->data[q ->front];
    q ->front = (q ->front+1)%MAX_SIZE;/*后移*/
    return _outcome = _success_;
}

队列长度(Length)

/*******************************************
 * 函数名称：LengthQueue(PtrQueue que)
 * 功能描述：
 * 传入参数：
 * 返回值：队列的长度
 * 队列长度计算：
 *          (rear-frot+MAX_SIZE)%MAX_SIZE 
 ******************************************/
int LengthQueue(PtrQueue que)
{
    return ((que ->rear) - (que ->front)+MAX_SIZE)%MAX_SIZE;
}

---

二、队列的链式存储结构

宏定义及结构声明

#define bool int
#define TRUE 1
#define FALSE 0

/*定义待处理的数据类型*/
typedef int Elemtype;

/*定义函数返回值类型*/
typedef enum Status{
    _Success_,
    _Fail_
}Status;

/*定义链队列的结点类型*/
typedef struct QueueNode
{
    Elemtype data;
    struct QueueNode* next;
}QueueNode,*PtrQueueNode;

/*定义队列类型，包含头尾两个指针*/
typedef struct Queue
{
    PtrQueueNode front;/*头指针*/
    PtrQueueNode rear;/*尾指针*/
}Queue,*PtrQueue;

链队列的初始化(Init)

/*********************************************
 * 函数名称：QueueLinkInit(PtrQueue que_)
 * 功能描述：初始化链队列 que_
 * 输入参数：PtrQueue que_ 传入待初始化的链队列
 * 返回值：_Success_ 成功
 *        _Fail_    失败
 * *******************************************/
Status QueueLinkInit(PtrQueue que_)
{
    Status outcome = _Fail_;
    que_ -> front = (PtrQueueNode)malloc(sizeof(QueueNode));/*申请空间*/
    if(!que_ -> front)
    {
        return outcome;/*空间申请失败*/
    }
    else
    {
        que_ -> front -> next = NULL;
        que_ -> rear = que_ -> front;
        outcome = _Success_;
    }
    return outcome;    
}

链队列的销毁(Destroy)

/*******************************************
 * 函数名称：DestroyQueue(PtrQueue _que_)
 * 功能描述：销毁链队列 _que_
 * 传入参数：PtrQueue _que_ 待销毁的链队列
 * 返回值：_Fail_    失败
 *         _Success_ 成功
 ******************************************/
Status DestroyQueue(PtrQueue _que_)
{
    Status _outcome_ =_Fail_;
    while (_que_ -> front)
    {
        _que_ -> rear = _que_ -> front -> next;/*链队列为空则头尾指针相等*/
        free(_que_ -> front);
        _que_ -> front = _que_ -> rear;
        _outcome_ = _Success_;
    }
     return _outcome_;
}

链队列入队(Insert)

/*********************************************************
 * 函数名称：InsertQueue(PtrQueue _que_, Elemtype e)
 * 功能描述：在链队列_que_的队尾插入数据e
 * 输入参数：PtrQueue _que_     传入的链队列
 *           Elemtype e         待插入的数据
 * 返回值： _Fail_   失败
 *          _Success 成功 
 ********************************************************/
Status InsertQueue(PtrQueue _que_, Elemtype e)
{
    Status _outcome_ = _Fail_;
    PtrQueueNode s = (PtrQueueNode)malloc(sizeof(QueueNode));
    if(!s)
    {
        _outcome_ = _Fail_;
    }
    else
    {
        s -> data = e;
        s -> next = NULL;
        _que_ -> rear -> next = s;/*添加到队列尾部*/
        _que_ -> rear = s;/*更新队尾指针*/
        _outcome_ = _Success_;
    }
    return _outcome_;
}

链队列出队(Out)

/***************************************************
 * 函数名称：GetTopQueue(PtrQueue _que_,int topdata)
 * 功能描述：若链队列不空返回队列顶数据
 * 传入参数：PtrQueue _que_ 待测链队列
 *           topdata        队列顶数据赋值给topdata
 * 返回值：_Success_  成功
 *         _Fail_     失败
 ***************************************************/
Status GetTopQueue(PtrQueue _que_,Elemtype topdata)
{
    Status _outcome_ = _Success_;
    PtrQueueNode q;
    if(_que_ -> front == _que_ -> rear)
    {
        _outcome_ = _Fail_;
    }
    else
    {
        q = _que_ ->front ->next;
        topdata = q -> data;
        _que_ ->front ->next = q ->next;
        if(_que_ ->rear == q)
        {
            _que_ ->rear = _que_ ->front;
        }
        free(q);
    }
    return _outcome_;
}

计算链队列长度(Length)

/*******************************************
 * 函数名称：QueueLength(PtrQueue _que_)
 * 功能描述：计算链队列_que_长度 
 * 传入参数：PtrQueue _que_ 待测链队列
 * 返回值：count 链队列长度
 ******************************************/
int QueueLength(PtrQueue _que_)
{
    Status _outcome_ = _Fail_;
    int count = 0;
    PtrQueueNode q = _que_ -> front -> next;
    while (q)
    {
        count++;
        q = q -> next;
    }
    return count;
}

判断链队列是否为空(Empty)

/*******************************************
 * 函数名称：QueueEmpty(PtrQueue _que_)
 * 功能描述：判断链队列 _que_是否为空
 * 传入参数：PtrQueue _que_ 待判断的链队列
 * 返回值：TRUE    非空
 *         FALSE   空
 ******************************************/
bool QueueEmpty(PtrQueue _que_)
{
    if(_que_ -> front == _que_ -> rear)
    {
        return TRUE;/*空队列*/
    }
    else
    {
        return FALSE;
    }
}

---

🤔
o_o …
◑﹏◐