数据结构之队列的实现

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

队列的结构体及其接口：

#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]#