数据结构之队列的实现

最新推荐文章于 2023-04-16 13:21:19 发布
最新推荐文章于 2023-04-16 13:21:19 发布
阅读量380 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_33736971/article/details/51012295
版权

利用双端链表实现队列的基本操作

队列的结构体及其接口：

#ifndef _QUEUE_H_
#define _QUEUE_H_

#include "dlist.h"

typedef struct Queue{
    Dlist *dlist;
}Queue;

Queue *init_queue(void);  //队列的初始化
void destroy_queue(Queue **queue);  //队列的销毁
Boolean is_empty(Queue *queue);
Boolean input(Queue *queue, void *value);
Boolean output(Queue *queue);
Boolean get_queue_front(Queue *queue, void **value);
int  get_count(Queue *queue);


#endif

队列的接口实现：

#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include "queue.h"


Queue *init_queue(void)  //队列的初始化
{
    Queue *queue = NULL;

    queue = (Queue *)Malloc(sizeof(Queue));
    queue->dlist = init_dlist();

    return queue;
}

void destroy_queue(Queue **queue)  //队列的销毁
{
    if(queue == NULL || *queue == NULL){
        return ;
    }

    destroy_dlist(&(*queue)->dlist);
    free(*queue);
    *queue = NULL;
}

Boolean is_empty(Queue *queue)
{
    return get_dlist_count(queue->dlist) == ZERO;
}

Boolean input(Queue *queue, void *value)
{
    if(queue == NULL || value == NULL){
        return FALSE;
    }

    return push_back(queue->dlist, value);
}
Boolean output(Queue *queue)
{
    if(queue == NULL){
        return FALSE;
    }

    return pop_front(queue->dlist);
}

Boolean get_queue_front(Queue *queue, void **value)
{
    if(!is_empty(queue) && value != NULL){
        return get_front(queue->dlist, value);
    }

    return FALSE;
}
int  get_count(Queue *queue)
{
    if(queue == NULL){
        return -1;
    }

    return get_dlist_count(queue->dlist);
}

队列所需的包裹函数的声明：

#ifndef _TOOLS_H_
#define _TOOLS_H_

//定义布尔类型
#define TRUE  (1)
#define FALSE (0)

typedef unsigned char Boolean;

//定义接口
void *Malloc(size_t size);

#endif

队列所需的包裹函数的实现:

#include <stdio.h>
#include <stdlib.h>
#include "tools.h"

void *Malloc(size_t size)
{
    void *result = malloc(size);
    if(result == NULL){
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    }

    return result;
}

实现队列依赖的双端链表的声明：

#ifndef _DLIST_H_
#define _DLIST_H_
#include "tools.h"

#define TRUE   (1)
#define FALSE  (0)
#define ZERO   (0)
#define ONE    (1)

typedef void (*Print_func)(void *value);   //回调函数

//链表节点类型
typedef struct Dlist_node{
    struct Dlist_node *prev;  //前驱
    struct Dlist_node *next;  //后继
    void              *data;  //可以接收任意类型的指针（达到通用的效果）
}Dlist_node;

//链表控制信息
typedef struct Dlist{
    struct Dlist_node *head; //头结点
    struct Dlist_node *tail; //尾节点
    int               count; //数量

    //data所指向内容的释放策略
    void (*free)(void *ptr); //释放任意指针的空间（函数指针）
    //data所指向内容的相等策略
    Boolean (*match)(void *value1, void *value2);
    //data所指向内容的拷贝策略
    void *(*copy_node)(void *value);
}Dlist;

//通用链表的接口定义
Dlist   *init_dlist(void)                                       ;  //双端链表初始化
void    destroy_dlist(Dlist **dlist)                            ;  //双端链表的销毁
Boolean push_front(Dlist *dlist, void *value)                   ;  //头部插入
Boolean push_back(Dlist *dlist, void *value)                    ;  //尾部插入
Boolean pop_front(Dlist *dlist)                                 ;  //头部删除
Boolean pop_back(Dlist *dlist)                                  ;  //头部删除

Dlist_node *find_node(Dlist *dlist, void *value)                ;
Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value);  //插入到指定节点前边
Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value);  //插入到指定节点后边
Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node)       ;  //删除指定节点
void    print_dlist(Dlist *dlist, Print_func print)             ;  //链表的打印
Boolean get_front(Dlist *dlist, void **value)                   ;  //得到头结点的data
//Boolean get_front(Dlist *dlist, void *value)                  ;  //得到头结点的data
Boolean get_tail(Dlist *dlist, void **value)                     ;  //得到尾节点的data
int     get_dlist_count(Dlist *dlist)                           ;   //得到链表的数量


#endif

队列实现所用的链表的接口实现：

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "dlist.h"


Dlist   *init_dlist(void)                                         //双端链表初始化
{
    Dlist *dlist = NULL;

    dlist = (Dlist *)Malloc(sizeof(Dlist));
    bzero(dlist, sizeof(Dlist));

    return dlist;
}

void    destroy_dlist(Dlist **dlist)                              //双端链表的销毁
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || *dlist == NULL){
        return ;
    }

#if 0
    p_node = (*dlist)->head;

    while((*dlist)->head != NULL){
        (*dlist)->head = p_node->next;
        if((*dlist)->free != NULL){
            (*dlist)->free(p_node->data);
        }
        free(p_node);
        p_node = (*dlist)->head;
    }
#endif

    while((*dlist)->count){
        pop_front(*dlist);
    }
    free(*dlist);
    *dlist = NULL;
}

static Dlist_node *create_node(void);   //生成链表节点
static Dlist_node *create_node(void)
{
    Dlist_node *result = NULL;

    result = (Dlist_node *)Malloc(sizeof(Dlist_node));
    bzero(result, sizeof(Dlist_node));

    return result;
}

Boolean push_front(Dlist *dlist, void *value)                     //头部插入
{
    //*value记录数据的地址
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        return FALSE;
    }

    //生成链表节点
    p_node = create_node();
    p_node->data = value;

    if(dlist->count == ZERO){     //插入前无元素
        dlist->head = dlist->tail = p_node;
    }else{      //插入前有元素
        p_node->next = dlist->head;
        dlist->head->prev = p_node;
        dlist->head = p_node;
    }

    dlist->count++;
    return TRUE;
}

Boolean push_back(Dlist *dlist, void *value)                      //尾部插入
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        p_node->prev = dlist->tail;
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    if(dlist->count == ZERO){     //插入前无元素
        dlist->head = dlist->tail = p_node;
    }else{    //插入前有元素
        dlist->tail->next = p_node;
        p_node->prev = dlist->tail;
        dlist->tail = p_node;
    }

    dlist->count++;
    return TRUE;
}

Boolean pop_front(Dlist *dlist)                                   //头部删除
{
    Dlist_node *p_node = NULL; 

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->head;

    if(dlist->count == ONE){
        dlist->head = dlist->tail = NULL;
    }else{
        dlist->head = p_node->next;
        dlist->head->prev = NULL;
    }

    //释放节点，要对free指针作判断（data指向为堆还是栈）
    if(dlist->free != NULL){   //堆上（才可用free函数）
        dlist->free(p_node->data);
    }

    free(p_node);   //栈上
    dlist->count--;
    return TRUE;
}

Boolean pop_back(Dlist *dlist)                                    //头部删除
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->tail;

    if(dlist->count == ONE){   //只有一个元素
        dlist->head = dlist->tail = NULL;
    }else{    //多个元素
        dlist->tail = p_node->prev;
        dlist->tail->next = NULL;
    }

    if(dlist->free != NULL){
        dlist->free(p_node->data);
    }

    free(p_node);
    dlist->count--;

    return TRUE;
}

Dlist_node *find_node(Dlist *dlist, void *value)
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        return NULL;
    }

#if 0
    for(p_node = dlist->head; p_node; p_node = p_node->next){
        if(dlist->match){     //用户指定相等条件
            if(!dlist->match(p_node->data, value)){
                return p_node;
            }
        }else{
            if(p_node->data == value){
                return p_node;
            }
        }
    }
#endif

    if(dlist->match){
        for(p_node = dlist->head; p_node; p_node = p_node->next){
            if(!dlist->match(p_node->data, value)){
                return p_node;
            }
        }
    }else{ 
        for(p_node = dlist->head; p_node; p_node = p_node->next){
            if(p_node->data == value){
                return p_node;
            }
        }
    }

    return p_node;
}

Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value)  //插入到指定节点前边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value == NULL){
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    p_node->next = node;
    p_node->prev = node->prev;

    if(node->prev == NULL){
        dlist->head = p_node;
    }else{
        node->prev->next = p_node;
    }

    node->prev = p_node;
    dlist->count++;

    return TRUE;
}

Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value)  //插入到指定节点后边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value == NULL){
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    p_node->prev = node;
    p_node->next = node->next;

    if(node->next == NULL){
        dlist->tail = p_node;
    }else{
        node->next->prev = p_node;
    }

    node->next = p_node;
    dlist->count++;

    return TRUE;
}

Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node)         //删除指定节点
{   //被删除节点的位置1.头删2.尾删3.中间删
    if(dlist == NULL || node == NULL ){
        return FALSE;
    }

    if(node->next == NULL){   //尾删
        pop_back(dlist);
    }else if(node->prev == NULL){  //头删
        pop_front(dlist);
    }else{   //中间删
        node->prev->next = node->next;
        node->next->prev = node->prev;

        if(dlist->free != NULL){
            dlist->free(node->data);
        }
        free(node);
        dlist->count--;
    }

    return TRUE;
}

void    print_dlist(Dlist *dlist, Print_func print)               //链表的打印
{
    Dlist_node *p_node = NULL;   

    if(dlist == NULL || print == NULL || dlist->count == ZERO){
        return ;
    }

    p_node = dlist->head;

    while(p_node){
        print(p_node->data);    //print由使用者选择是哪种类型
        p_node = p_node->next;
    }

    printf("\n");
}

Boolean get_front(Dlist *dlist, void **value)                     //得到头结点的data
{
    if(dlist == NULL || value == NULL || dlist->count == ZERO){
        return FALSE;
    }

    *value = dlist->head->data;

    return TRUE;
}

//Boolean get_front(Dlist *dlist, void *value)                    //得到头结点的data
Boolean get_tail(Dlist *dlist, void **value)                       //得到尾节点的data
{
     if(dlist == NULL || dlist->count == ZERO || value == NULL){
         return FALSE;
     }

     *value = dlist->tail->data;

     return TRUE;
}

int     get_dlist_count(Dlist *dlist)                             //得到链表的数量
{
    if(dlist == NULL){
        return -1;
    }

    return dlist->count;
}

队列实现的测试代码：

#include <stdlib.h>
#include <stdio.h>
#include "queue.h"
#include "tools.h"

int main(int ac, char **av)
{
    Queue *queue = NULL;
    int array[] = {21, 34, 56, 65, 76, 74, 78};
    int  i = 0;
    int arr_len = sizeof(array) / sizeof(array[0]);
    void *value = NULL;

    queue = init_queue();
    for(i = 0; i < arr_len; ++i){
        input(queue, &array[i]);
    }

    for(i = 0; i < arr_len; ++i){
        get_queue_front(queue, &value);
        output(queue);
        printf("%d ", *(int *)value);
    }
    printf("\n");

    destroy_queue(&queue);
    return 0;
}

队列实现的测试结果：

[root@localhost queue_dlist]# ./queue 
21 34 56 65 76 74 78 
[3]+  Done                    gedit queue.* tools.* dlist.* main.c
[root@localhost queue_dlist]#
lm_123_456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 — 双向链表
烟云的计算
05-04 3247
目录 文章目录目录双向链表跳表 双向链表 双向链表支持顺序查找和逆序查找，如下图： 所以双向链表也常被称之为环（Ring），常见于处理网络数据包的内存缓存空间的组织。双向链表的缺点是不支持按某个值或区间的快速查找，也不支持数据的快速插入。 跳表 跳表是在链表之上加上多层索引构成的，相对于双向链表，支持快速查找，更新，删除。 假设我们现在要查找区间 7- 13 的记录，就不用从头开始查找了，只要...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
C语言数据结构之双链表---链表&数据分离（从零写一个双链）
假如技术娶了生活...
08-01 501
双链程序
双向链表，还能这么实现
实力程序员
06-08 170
双向链表，是一种常用的数据结构。在C语言中，双向链表的实现，通常采用下面的数据结构： typedef struct dlist_node_t { struct dlist_node_t* pprev; struct dlist_node_t* pnext; void* pdata; } dlist_node_t; typedef struct dlist_t { dlist_node_t* phead; dlist_node_t* ptail; } dlist_t;...
Postgresql源码（45）SysCache内存结构与搜索流程分析
InternalsOf
05-09 816
1 内存结构和查询步骤 查询步骤概要 使用SysCacheIdentifier在CatCache数组中找到对应的CatCache 计算hash，按数组index找到bucket 找到bucket后，在bucket双向链表中遍历找到CatCTup，元组记录在其中；找到后调整到双向链表头（LRU） 多条查询步骤概要 cc_lists用与多条数据查询 计算hash，按顺序匹配每个catclist，找到catclist 如果List可用直接返回。注意catclist中再结构体后面记录了该List指向的所有Ca
＜ 数据结构 ＞ 队列的实现
bit_zyx的博客
04-05 2435
前言 队列的概念 队结的结构 队列的应用场景 队列的实现 创建队列结构 队列初始化 队列销毁 入队列 出队列 队列判空 获取队列元素个数 获取队列头部元素 获取队列尾部元素 总代码 Queue.h 文件 Queue.c 文件 Test.c
数据结构之队列
jiaomubai的博客
02-05 3429
什么是队列 队列（queue）是一种线性数据结构。与同为线性数据结构的栈不同的是队列中的元素遵循的是先进先出（First In First Out）的规则，和在现实中排队一样，讲究的是先来后到的原则。队列出口端叫做队头（front），队列的入口端叫做队尾（rear）。 与栈类似，队列这种线性数据结构既可以用数组来实现，也可以用链表来实现。用数组来实现时，我们可以自行规定队尾的位置，比如说规定最后一个元素的下一个位置为队尾，或者规定最后一个元素所在的位置为队尾，这两种都行，毕竟是自己实现的。本文规定最后一
数据结构之队列总结
Grand.的博客
05-17 1730
数据结构之队列
线性数据结构之队列(Queue)
热门推荐
刘跃辉的博客
09-05 9万+
队列是一种用来存储数据的数据结构 , 与链表和栈类似 , 数据到达的次序是队列的关键 , 类似于生活中我们在排队购买东西时 , 第一个人是队首 , 最后一个人是队尾 , 第一个人先买到东西后离开 , 这个时候第二个人便成了队首 , 以此类推…队列中第一个插入的元素也是第一个被删除的元素 , 所以队列是一种先进先出(First In First Out 简称 FIFO)或者后进后出(Last In Last Out 简称 LILO)的线性表。
数据结构——队列（C语言实现）
sinzz的博客
04-16 2792
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
数据结构之循环队列
qq_53010164的博客
04-12 7208
目录 一、循环队列的概念 二、设计循环队列 思路一：数组实现 思路二：链表实现 一、循环队列的概念 为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。 环形队列可以使用数组实现，也可以使用循环链表实现。 重点:循环队列，无论使用数组实现还是链表实现，都要多开一个空间，也就意味着，要是一个存.
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
Python 数据结构之队列的实现
09-21
主要介绍了Python 数据结构之队列的实现的相关资料,需要的朋友可以参考下
c语言数据结构的队列实现
07-02
c语言数据结构的队列实现，新建队列，入队列，出队列，删除队列
数据结构–队列（Java实现）
01-21
数据结构–队列（Java实现） 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 简介 队列是一种特殊的线性表，特殊之处在于它只允许在表的...
常见排序的最好，平均以及最坏时间复杂度
github_33736971的博客
08-06 1万+
下面是常用排序的时间复杂度的比较总结，希望可以帮助到大家哦^_^
数据结构之双端（通用）链表的实现
github_33736971的博客
03-30 614
从单链表可以了解到，若是要添加一个链表元素除第一个元素外其他都必须将链表遍历一遍才可以添加；当数据量比较大时向尾部添加元素就比较麻烦，于是就出现了双端链表； 双端链表和单链表相比多了一个指向尾节点的指针，对于进行尾部插入方便了很多； 以下是双端链表的实现：双端链表的链表控制信息及其链表节点信息：#ifndef _DLIST_H_ #define _DLIST_H_ #include "too
数据结构之顺序表的实现
github_33736971的博客
04-05 536
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。以下是用C++实现的顺序表的接口操作： 其.cpp文件如下： #include <stdlib.h> #include "test.h"int main() { Seqlis
数据结构之选择排序<select_sort>
github_33736971的博客
07-21 399
选择排序其实就是将待排序列的第一个记录标记为最小，然后将其与剩余的其他记录比较找到最小的并交换，然后将标记后移并和剩余的其他记录比较其实现如下：void select_sort(int *array, int length) { int min_index = 0; //标记最小值下标 int i = 0; int j = 0; int temp = 0;
数据结构链队列的实现
最新发布
11-03
链队列的实现需要定义一个队列结构体，包含队头和队尾指针，以及链表节点结构体，包含数据域和指向下一个节点的指针。链队列的入队操作需要在队尾插入新节点，出队操作需要在队头删除节点。具体实现细节如下： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值