数据结构顺序队列和链队列的数据封装

最新推荐文章于 2024-08-20 19:30:24 发布
最新推荐文章于 2024-08-20 19:30:24 发布
阅读量404 收藏 10
点赞数 3
文章标签： 数据结构 算法 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ksk6666/article/details/140951978
版权

顺序队列

定义数据结构：

typedef void (queue_op_t)(const void *);


typedef struct queue {
    void *queue;
    int size;
    int max;
    int front;
    int rear;
} QUEUE;


//初始化
QUEUE *queue_creat(int size, int max);
//入队
int queue_push(QUEUE *handle, void *data);
//出队
void *queue_pop(QUEUE *handle);
//判断满队
int queue_is_full(QUEUE *handle);
//判断空队
int queue_is_empty(QUEUE *handle);
//遍历
void queue_travel(QUEUE *handle, queue_op_t *op);
//销毁
void queue_destroy(QUEUE **handle);
//清空
void queue_clean(QUEUE *handle);
//num
int queue_num(QUEUE *handle);
//存储
void queue_store(QUEUE *handle, const char *path);
//加载
QUEUE *queue_load(const char *path);

init creat

QUEUE *queue_creat(int size, int max)
{
    QUEUE *handle = (QUEUE *)malloc(sizeof(QUEUE));
    ERRP(handle == NULL, "handle malloc", goto ERR1);

    handle->queue = malloc(max * size);
    ERRP(handle->queue == NULL, "queue malloc", goto ERR2);

    handle->size = size;
    handle->max = max;
    handle->front = 0;
    handle->rear = 0;

    return handle;

ERR2:
    free(handle);
ERR1:
    return NULL;
}

**push **

int queue_push(QUEUE *handle, void *data)
{
    if (queue_is_full(handle))
    {
        printf("queue is full, can't push\n");
        return 0;
    }
    else
    {
        memmove(handle->queue + handle->rear * handle->size, data, handle->size);
        handle->rear = (handle->rear + 1) % handle->max;
    }
    return 1;
}

pop

void *queue_pop(QUEUE *handle)
{
    if (queue_is_empty(handle))
    {
        printf("queue is empty, can't pop\n");
        return NULL;
    }
    else
    {
        void *data = malloc(handle->size);
        ERRP(data == NULL, "data malloc", goto ERR1);

        memmove(data, handle->queue + handle->front * handle->size, handle->size);
        handle->front = (handle->front + 1) % handle->max;

        return data;
    }

ERR1:
    return NULL;
}

is_full

int queue_is_full(QUEUE *handle)
{
    return (handle->rear + 1) % handle->max == handle->front;
}

is_empty

int queue_is_empty(QUEUE *handle)
{
    return handle->front == handle->rear;
}

traval

void queue_travel(QUEUE *handle, queue_op_t *op)
{
    int i = handle->front;
    while (i != handle->rear)
    {
        op(handle->queue + i * handle->size);
        i = (i + 1) % handle->max;
    }
}

destroy

void queue_destroy(QUEUE **handle)
{
    free((*handle)->queue);
    free(*handle);
    *handle = NULL;
}

**clean **

void queue_clean(QUEUE *handle)
{
    handle->front = 0;
    handle->rear = 0;
}

num count

int queue_num(QUEUE *handle)
{
    if (handle->rear >= handle->front)
    {
        return handle->rear - handle->front;
    }
    else
    {
        return handle->max - (handle->front - handle->rear);
    }
}

file io

// 存储
void queue_store(QUEUE *handle, const char *path)
{
    FILE *fp = fopen(path, "w");
    ERRP(fp == NULL, "fopen", goto ERR1);

    if (fwrite(handle, sizeof(*handle), 1, fp) != 1)
    {
        perror("fwrite");
        goto ERR2;
    }

    int i = handle->front;
    while (i != handle->rear)
    {
        if (fwrite(handle->queue + i * handle->size, handle->size, 1, fp) != 1)
        {
            perror("fwrite");
            goto ERR2;
        }
        i = (i + 1) % handle->max;
    }

    fclose(fp);
    return;

ERR2:
    fclose(fp);
ERR1:
    return;
}

// 加载
QUEUE *queue_load(const char *path)
{
    FILE *fp = fopen(path, "r");
    ERRP(fp == NULL, "fopen", goto ERR1);

    QUEUE *handle = (QUEUE *)malloc(sizeof(QUEUE));
    ERRP(handle == NULL, "handle malloc", goto ERR2);

    if (fread(handle, sizeof(*handle), 1, fp) != 1)
    {
        perror("fread");
        goto ERR2;
    }

    handle->queue = malloc(handle->max * handle->size);
    ERRP(handle->queue == NULL, "queue malloc", goto ERR3);

    int i = handle->front;
    while (i != handle->rear)
    {
        if (fread(handle->queue + i * handle->size, handle->size, 1, fp) != 1)
        {
            perror("fread");
            goto ERR4;
        }
        i = (i + 1) % handle->max;
    }

    fclose(fp);
    return handle;

ERR4:
    free(handle->queue);
ERR3:
    free(handle);
ERR2:
    fclose(fp);
ERR1:
    return NULL;
}

链队列

定义数据结构：

typedef void (queue_op_t)(const void *);


typedef struct lqueue_node {
    void *data; // 数据
    struct lqueue_node *next; // 指向下一个节点的指针
}LQUEUE_NODE;

// 定义链式队列
typedef struct lqueue {
    LQUEUE_NODE *front; // 队头指针
    LQUEUE_NODE *rear;  // 队尾指针
    int size; // 队中数据类型大小
    int count; // 队列中元素的数量
}LQUEUE;

//初始化
LQUEUE *lqueue_creat(int size);
//入队
int lqueue_push(LQUEUE *handle, void *data);
//出队
void *lqueue_pop(LQUEUE *handle);
//判断空队
int lqueue_is_empty(LQUEUE *handle);
//遍历
void lqueue_travel(LQUEUE *handle, queue_op_t *op);
//销毁
void lqueue_destroy(LQUEUE **handle);
//清空
void lqueue_clean(LQUEUE *handle);
//num
int lqueue_num(LQUEUE *handle);
//存储
void lqueue_store(LQUEUE *handle, const char *path);
//加载
LQUEUE *lqueue_load(const char *path);

// init creat

LQUEUE *lqueue_creat(int size)
{
    LQUEUE *handle = (LQUEUE *)malloc(sizeof(LQUEUE));
    if (handle == NULL)
    {
        perror("handle malloc");
        return NULL;
    }

    handle->front = NULL;
    handle->rear = NULL;
    handle->size = size;
    handle->count = 0;

    return handle;
}

**push **

int lqueue_push(LQUEUE *handle, void *data)
{
    LQUEUE_NODE *new_node = (LQUEUE_NODE *)malloc(sizeof(LQUEUE_NODE));
    if (new_node == NULL)
    {
        perror("new_node malloc");
        return 0;
    }

    new_node->data = (void *)malloc(handle->size);
    if (new_node->data == NULL)
    {
        perror("data malloc");
        free(new_node);
        return 0;
    }

    memcpy(new_node->data, data, handle->size);
    new_node->next = NULL;

    if (handle->rear == NULL)
    {
        handle->front = new_node;
    }
    else
    {
        handle->rear->next = new_node;
    }

    handle->rear = new_node;
    handle->count++;
    return 1;
}

pop

void *lqueue_pop(LQUEUE *handle)
{
    if (handle->front == NULL)
    {
        printf("queue is empty, can't pop\n");
        return NULL;
    }

    LQUEUE_NODE *node = handle->front;
    void *data = node->data;

    handle->front = node->next;
    if (handle->front == NULL)
    {
        handle->rear = NULL;
    }

    free(node);
    handle->count--;
    return data;
}

empty

int lqueue_is_empty(LQUEUE *handle)
{
    return handle->count == 0;
}

traval

void lqueue_travel(LQUEUE *handle, queue_op_t *op)
{
    LQUEUE_NODE *current = handle->front;
    while (current != NULL)
    {
        op(current->data);
        current = current->next;
    }
}

destroy

void lqueue_destroy(LQUEUE **handle)
{
    lqueue_clean(*handle);
    free(*handle);
    *handle = NULL;
}

clean

void lqueue_clean(LQUEUE *handle)
{
    while (!lqueue_is_empty(handle))
    {
        void *data = lqueue_pop(handle);
        free(data);
    }
}

num count

int lqueue_num(LQUEUE *handle)
{
    return handle->count;
}

file io

// 存储
void lqueue_store(LQUEUE *handle, const char *path)
{
    FILE *fp = fopen(path, "w");
    if (fp == NULL)
    {
        perror("fopen");
        return;
    }

    fwrite(&handle->size, sizeof(int), 1, fp);
    fwrite(&handle->count, sizeof(int), 1, fp);

    LQUEUE_NODE *current = handle->front;
    while (current != NULL)
    {
        fwrite(current->data, handle->size, 1, fp);
        current = current->next;
    }

    fclose(fp);
}

// 加载
LQUEUE *lqueue_load(const char *path)
{
    FILE *fp = fopen(path, "r");
    if (fp == NULL)
    {
        perror("fopen");
        return NULL;
    }

    LQUEUE *handle = (LQUEUE *)malloc(sizeof(LQUEUE));
    if (handle == NULL)
    {
        perror("handle malloc");
        fclose(fp);
        return NULL;
    }

    fread(&handle->size, sizeof(int), 1, fp);
    fread(&handle->count, sizeof(int), 1, fp);

    handle->front = NULL;
    handle->rear = NULL;

    for (int i = 0; i < handle->count; i++)
    {
        void *data = malloc(handle->size);
        if (data == NULL)
        {
            perror("data malloc");
            lqueue_destroy(&handle);
            fclose(fp);
            return NULL;
        }

        fread(data, handle->size, 1, fp);
        lqueue_push(handle, data);
        free(data);
    }

    fclose(fp);
    return handle;
}
只是想学习
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构不挂科-3-栈和队列.pdf
07-17
然而，标准库通常不直接提供栈和队列的数据结构，开发者需要自行实现或利用现有的库函数，如在C++标准模板库（STL）中，`stack`和`queue`容器已经封装好。 ### 例题解析 关于栈的应用，例如例题3-1中描述了一个...
计算机数据结构笔记-计算机数据结构
05-26
数据结构主要包括逻辑结构、存储结构和数据运算三个方面。 1. 数据结构的逻辑结构是指数据元素之间的逻辑关系，不考虑实际在计算机中的存储方式。主要有线性结构（如线性表、栈、队列）和非线性结构（如树、图、...
【数据结构】链队列的C语言实现
Sherry的博客
03-22 1513
今天我们认识并学习了队列的相关概念、结构与接口实现，并且针对每个常用的功能接口进行了实现。总体来说，链队列的结构相比于之前的数据结构是比较简单的，之后将介绍和讲解栈与队列的相关OJ题。希望我的文章和讲解能对大家的学习提供一些帮助。
【数据结构】带你深度理解队列
忆梦初心的博客
04-01 2466
与栈同理，队列也是一种限制型的数据结构，不支持随机访问。其只允许在固定的两端进行操作。因此也不存在查找，打印，修改等需要对其他位置进行操作的接口，否则会破坏队列的特性。数据结构的实现方式多种多样，为了在隐藏设计细节的情况下使用方依旧能够很方便的使用，尽管有一些操作仅仅只有一两行代码，我们还是封装成函数作为对外的接口供使用方调用。
【数据结构】队列
Welcome home | Jian Liao 's blog
03-20 1380
🍎栈和队列可以说是一对好兄弟，前面学习了栈，那队列当然也少不了。对于栈而言，队列可以说具有与他相反的性质，本章就给大家领悟一下队列的魅力。🍒队列是一种简单的数据结构，它的主要性质，就是数据先进先出(FIFO单调队列等等。所以说，我们要熟练其性质。💝队列还是比较简单呢，只要能够实现前面的数据结构，队列也可以说是洒洒水嘞。❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！
【数据结构】C语言实现链队列(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
11-25 1156
使用C语言实现链队列程序新手入门详解.包括每个函数的设计思路及程序的完整代码.
数据结构 - 链式队列
weixin_49303682的博客
12-26 2770
1.链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储 区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 2.创建链式队列 为链式队列申请内存，即为队首指针和队尾指针申请内存。 为链式队列头结点申请内存，头结点不存放有效数据，方便队列的操作。 将队首指针和队尾指针指向头结点，即队首指针和队尾指针相等。 链式队列头结点指针域为空，即为NULL；头结点数据域可不管，亦可为零，作为链式队列有效的
C语言数据结构之队列
ONLY1024的博客
02-02 492
Queue 队列与栈结构不同的是，队列两头都是“开口”，数据只能从一段进入然后从另一端出去，中间不可存在“插队”一说。如图所示： 我们通常把进队列的一段叫做“队尾”，把出队列的一段叫做“队头”，把进数据叫做”入队“，把出数据叫做”出队“，与栈结构不同的是，队列遵循“先进先出”的原则，这好比我们排队买票也是遵循”先进先出“的原则来的。例如图一中1入队后想要出队，则需先让3出队，然后2出队，方可1出队。 队列的存储结构的实现可以有两种方式： 1.顺序队列：在顺序表的基础上的队列实现； 2.链式队列：在链表的基
数据结构——队列的详解
晴空๓
04-21 5216
队列和栈相反，队列(queue)是一种先进先出（FIFO:first in first out）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。队列和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。在队列中，允许插入的一端叫队尾（tear），允许删除的一端称为队头（front）
数据结构之——队列详解 ( 1 )
weixin_69283129的博客
09-01 1007
C语言版——数据结构链式存储（单链表型）队列的操作实现
数据结构——栈和队列
2301_78987687的博客
02-19 1052
在计算机这个学科中有两个栈，一个是软件层面的栈，一个是硬件层面的栈软件的栈是指一种“后入先出(Last In First Out)”数据结构，用于在内存中存储、管理数据硬件的栈是指,在计算机硬件中，由CPU管理的一块特殊的内存区域，用于支持程序的执行学习栈和队列需要用到顺序表和链表，不熟悉的可以在这篇文章里看一看链表与顺序表本篇文章介绍的是数据结构中的栈，并非硬件的栈栈底层由顺序表或链表实现，栈分为栈顶和栈底，栈顶用于插入数据和弹出数据，栈底没啥用(也许唯一的作用就是读取一下栈底的数据了)
数据结构与算法—顺序表、链接表、顺序栈、链接栈、顺序队列、链接队列的C++代码实现
weixin_43978744的博客
04-04 2166
顺序表、链接表、顺序栈、链接栈、顺序队列、链接队列的C++代码实现(基于C++模板)
数据结构和算法_数据结构_C++中的数据结构和算法_
10-01
在C++中，常见的数据结构有数组、链表、栈、队列、哈希表、树（如二叉树、AVL树、红黑树）和图等。数组是最基本的数据结构，提供随机访问但插入和删除操作较慢；链表则通过指针链接元素，便于动态调整大小，但在访问...
delphi 数据结构与算法 光盘原代码
01-06
- **队列**：先进先出（FIFO）的数据结构，适用于模拟执行顺序。 - **树**：分层结构，如二叉树、AVL树、红黑树，用于查找、排序等操作。 - **图**：用于表示对象之间的复杂关系，如邻接矩阵、邻接表等表示方式。...
各大公司算法数据结构笔试题.zip
04-19
数据结构与算法是计算机科学的基础，对于理解和解决复杂的计算问题至关重要。这个压缩包"各大公司算法数据结构笔试题.zip"包含了一系列与数据结构和算法相关的资料，旨在帮助备考者准备IT行业的笔试环节。以下是这些...
排序（归并排序，非比较排序）
qq_63074244的博客
08-20 523
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
数据结构之树的存储结构
DKPT的博客
08-16 532
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【Java & 数据结构】初识二叉树
最新发布
qq_42150700的博客
08-20 454
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构【顺序结构二叉树：堆】（1）
qq_67578580的博客
08-20 521
堆排序时间复杂度计算。
栈和队列的数据结构：链队列与栈的实现
链队列是数据结构中的一种，它采用链式存储结构来实现队列，允许在表尾进行插入和删除操作。链队列的节点由数据元素`ElemType`和指向下一个节点的指针`next`组成，而链队列本身则由头指针`front`和尾指针`rear`封装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值