数据结构之队列的实现

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