队列的基本操作

循环队列

Queue.h
Queue.c

动态队列

Queue.h
Queue.c

1、循环队列

Queue.h

#pragma once 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define MAX_SIZE 8

typedef int DataType;
typedef struct queue
{
    DataType _array[MAX_SIZE];      //队列
    DataType _front;                    
    DataType _back;
    int count;              //计数器
}Queue ,*PQueue;

void QueueInit(PQueue s);                   //队列初始化
void QueuePush(PQueue s, DataType data);    //队列进元素
void QueuePop(PQueue s);                    //删除元素
int QueueSize(PQueue s);                    //队列元素的个数
int QueueEmpty(PQueue s);                   //队列是否为空
DataType Queuefront(PQueue s);          //查看队头元素
DataType Queueback(PQueue s);               //查看队尾元素

void TestQueue();

Queue.c

#include "Queue.h"



//队列初始化
void QueueInit(PQueue s)
{
    assert(s);
    s->_front = s->_back = 0;
    s->count = 0;
}


//队列进元素
void QueuePush(PQueue s, DataType data)
{
    assert(s);
    if (MAX_SIZE == s->count)
    {
        printf("队列已满!\n");
        return;
    }

    s->_array[s->_back++] = data;
    if (s->_back == MAX_SIZE)
        s->_back = 0;
    s->count++;
}

//删除元素
void QueuePop(PQueue s)
{
    assert(s);
    if (0 == s->count)
        return;

    s->_front++;
    if (s->_front == MAX_SIZE)
        s->_front = 0;
    s->count--;
}

//队列元素的个数
int QueueSize(PQueue s)
{
    assert(s);
    return s->count;
}

//队列是否为空
int QueueEmpty(PQueue s)
{
    if (0 == s->count)
        return 1;

    return 0;
}

//查看队头元素
DataType Queuefront(PQueue s)
{
    assert(s);
    if (0 == s->count)
        exit(EXIT_FAILURE);

    return s->_array[s->_front];
}

//查看队尾元素
DataType Queueback(PQueue s)
{
    assert(s);
    if (0 == s->count)
        exit(EXIT_FAILURE);

    if (0 != s->_back)
    {
        return s->_array[s->_back - 1];
    }

    return s->_array[MAX_SIZE - 1];
}

void TestQueue()
{
    Queue s;
    QueueInit(&s);
    QueuePush(&s, 1);
    QueuePush(&s, 2);
    QueuePush(&s, 3);
    QueuePush(&s, 4);
    QueuePush(&s, 5);
    QueuePush(&s, 6);
    QueuePush(&s, 7);
    QueuePush(&s, 8);

    QueuePop(&s);                   //删除元素
    int size = QueueSize(&s);                   //队列元素的个数
    int ret = QueueEmpty(&s);                   //队列是否为空
    DataType a =Queuefront(&s);         //查看队头元素
    DataType b = Queueback(&s);             //查看队尾元素
}

2、动态队列

Queue.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int DataType;

typedef struct Node
{
    struct Node *_PNext;
    DataType _data;
}Node, *PNode;

typedef struct Queue
{
    PNode front;
    PNode rear;
}Queue, *PQueue;


//初始化队列
void QueueInit(PQueue q);

//入队
void QueuePush(PQueue q, DataType data);

//出队
void QueuePop(PQueue q);

//创建新结点
PNode BuyNode(DataType data);

//判空
int QueueEmpty(PQueue q);

//查看队头元素
DataType QueueFrontData(PQueue q);

//查看队尾元素
DataType QueueRearData(PQueue q);

//查看队列长度
int QueueSize(PQueue q);

//销毁队列
void QueueDestory(PQueue q);

Queue.c

#include "Queue.h"


//初始化队列
void QueueInit(PQueue q)
{
    assert(q);
    q->front = NULL;
    q->rear = NULL;
}

//入队
void QueuePush(PQueue q, DataType data)
{
    assert(q);
    if (NULL == q->front)
    {
        q->front = q->rear = BuyNode(data);
    }
    else
    {
        q->rear->_PNext = BuyNode(data);
        q->rear = q->rear->_PNext;
    }
}

//出队
void QueuePop(PQueue q)
{
    PNode pDel = NULL;
    assert(q);
    if (NULL == q->front)
    {
        return;
    }
    else
    {
        pDel = q->front;
        q->front = q->front->_PNext;
        free(pDel);
        pDel = NULL;
    }
}

//创建新结点
PNode BuyNode(DataType data)
{
    PNode pNewNode = (PNode)malloc(sizeof(Node));
    if (NULL == pNewNode)
    {
        exit(EXIT_FAILURE);
    }
    pNewNode->_data = data;
    pNewNode->_PNext = NULL;

    return  pNewNode;
}

//判空
int QueueEmpty(PQueue q)
{
    assert(q);

    if (NULL == q->front)
        return 1;

    return 0;
}

//查看队头元素
DataType QueueFrontData(PQueue q)
{
    assert(q);

    if (NULL == q->front)
        exit(EXIT_FAILURE);

    return q->front->_data;
}

//查看队尾元素
DataType QueueRearData(PQueue q)
{
    assert(q);

    if (NULL == q->front)
        exit(EXIT_FAILURE);

    return q->rear->_data;
}

//查看队列长度
int QueueSize(PQueue q)
{
    int count = 0;
    PNode pCur = NULL;
    assert(q);
    if (NULL == q->front)
    {
        return 0;
    }   
    else
    {
        pCur = q->front;
        while (pCur)
        { 
            count++;
            pCur = pCur->_PNext;
        }
    }

    return count;
}

//销毁队列
void QueueDestory(PQueue q)
{
    PNode pDel = NULL;
    PNode pCur = NULL;
    assert(q);
    if (NULL == q->front)
    {
        return;
    }
    else
    {

        pCur = q->front;
        q->front = NULL;
        while (pCur)
        {
            pDel = pCur;
            pCur = pCur->_PNext;
            free(pDel);
        }
    }
}