单向链式队列

目录

目录

• 单向链式队列
• 创建空链表
• 创建新结点
• 入队
• 判断链表是否为空
• 出队
• 遍历
• 代码验证

单向链式队列

/**

• @file name: main.c
• @brief 单向链式队列
• @author 1810866453@163.com
• @date 2024/04/23
• @version 1.0 ：版本
• @property ：属性介绍
• @note 补充 注意 说明
• CopyRight (c) 2023-2024 RISE_AND_GRIND@163.com All Right Reseverd
  */

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

// 指的是循环队列中的元素的数据类型，用户可以根据需要进行修改
typedef int DataType_t;

// 构造记录循环队列CircularQueue各项参数(循环队列的首地址 + 循环队列的容量 + 循环队列队尾下标+队首下标)的结构体
typedef struct LinkQueue
{
    DataType_t data;        // 结点的数据域
    struct LinkQueue *next; // 结点的指针域
    struct LinkQueue *Rear;
    struct LinkQueue *Front;

} LinkQueue_t;

创建空链表

// 创建一个空链表，空链表应该有一个头结点，对链表进行初始化
/**
 * @function name:	LList_Create
 * @brief  创建一个空链表，空链表应该有一个头结点，对链表进行初始化
 * @param  介绍函数参数 void
 * @retval void
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
LinkQueue_t *LList_Create(void)
{
    // 1.创建一个头结点并对头结点申请内存
    LinkQueue_t *Head = (LinkQueue_t *)calloc(1, sizeof(LinkQueue_t));
    if (NULL == Head)
    {
        perror("Calloc memory for Head is Failed");
        exit(-1);
    }

    // 2.对头结点进行初始化，头结点是不存储有效内容的！！！
    Head->next = NULL;
    Head->Front = NULL;
    Head->Rear = NULL;

    // 3.把头结点的地址返回即可
    return Head;
}

创建新结点

// 创建新的结点，并对新结点进行初始化（数据域 + 指针域）
/**
 * @function name:	LList_Create
 * @brief  创建新的结点，并对新结点进行初始化
 * @param  介绍函数参数 @data:新结点数据
 * @retval 新结点地址
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
LinkQueue_t *LList_NewNode(DataType_t data)
{
    // 1.创建一个新结点并对新结点申请内存
    LinkQueue_t *New = (LinkQueue_t *)calloc(1, sizeof(LinkQueue_t));
    if (NULL == New)
    {
        perror("Calloc memory for NewNode is Failed");
        return NULL;
    }

    // 2.对新结点的数据域和指针域进行初始化
    New->data = data;
    New->next = NULL;
    New->Front = NULL;
    New->Rear = NULL;

    return New;
}

入队

// 入队

/**
 * @function name:	LList_Create
 * @brief  入队
 * @param  介绍函数参数 @Head:头结点地址  @data:新结点数据
 * @retval bool
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
bool LinkQueue_Enqueue(LinkQueue_t *Head, DataType_t data)
{
    LinkQueue_t *New = LList_NewNode(data);
    LinkQueue_t *Phead = Head;
    // 判断新节点是否创建成功
    if (NULL == New)
    {
        printf("can not insert new node\n");
        return false;
    }
    // 判段链表是否为空,为空则可以直接插入
    if (Head->next == NULL)
    {
        Head->next = New;
        Head->Front = New;
        Head->Rear = New;
        return true;
    }
    // 遍历找到尾结点
    while (Phead->next)
    {
        Phead = Phead->next;
    }
    // 进行入队操作
    Head->Front = Head->next;
    Phead->next = New;
    Head->Rear = New;
    return true;
}

判断链表是否为空

/**
 * @function name:	LList_Create
 * @brief  判断循环队列是否为空
 * @param  介绍函数参数 @Head:头结点地址
 * @retval bool
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
// 判断循环队列是否为空
bool LinkQueue_IsEmpty(LinkQueue_t *Head)
{
    return (Head->next == NULL) ? true : false;
}

出队

// 出队
/**
 * @function name:	LList_Create
 * @brief  出队
 * @param  介绍函数参数 @Head:头结点地址
 * @retval 出队数据
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
// 判断循环队列是否为空
DataType_t LinkQueue_Dequeue(LinkQueue_t *Head)
{
    DataType_t temp = 0;
    LinkQueue_t *Phead = Head->next;
    // 1.判断循环队列是否为空
    if (LinkQueue_IsEmpty(Head))
    {
        return -1;
    }
    // 判断链表是否只有一个结点
    else if (Head->next->next == NULL)
    {
        temp = Phead->data;
        Head->next = NULL;
        Phead->next = NULL;
        free(Phead);
        return temp;
    }
    temp = Phead->data;
    Head->next = Head->next->next;
    Head->Front = Head->next->next;
    Phead->next = NULL;
    free(Phead);
    return temp;
}

遍历

/**
 * @function name:	LList_Create
 * @brief  遍历
 * @param  介绍函数参数 @Head:头结点地址
 * @retval 出队数据
 * @date 2024/04/26
 * @version 1.0 ：版本
 * @note   补充 注意 说明
 */
// 判断循环队列是否为空
void LinkQueue(LinkQueue_t *Head)
{
    // 对链表的头文件的地址进行备份
    LinkQueue_t *Phead = Head;

    // 首结点
    while (Phead->next)
    {
        // 把头的直接后继作为新的头结点
        Phead = Phead->next;

        // 输出头结点的直接后继的数据域
        printf("data = %d\n", Phead->data);
    }
}

代码验证

int main(int argc, char const *argv[])
{
    struct LinkQueue *Manager = LList_Create();

    LinkQueue_Enqueue(Manager, 1);
    LinkQueue_Dequeue(Manager);
    LinkQueue_Enqueue(Manager, 2);
    LinkQueue_Enqueue(Manager, 3);
    LinkQueue_Enqueue(Manager, 4);
    LinkQueue_Dequeue(Manager);
    LinkQueue(Manager);
    return 0;
}