基于单向链表的队列的实现

1.单链表实现

slist.h

#ifndef _SLIST_H
#define _SLIST_H

typedef struct _slist_node
{
    struct _slist_node *p_next; /* 指向下一个结点的指针 */
}slist_node_t;

typedef slist_node_t slist_head_t;
typedef int (*slist_node_process_t)(void *p_arg, slist_node_t *p_node);

int slist_init(slist_head_t *p_head);
int slist_add(slist_head_t *p_head, slist_node_t *p_pos, slist_node_t *p_node);
int slist_add_tail(slist_head_t *p_head, slist_node_t *p_node);
int slist_add_head(slist_head_t *p_head, slist_node_t *p_node);
int slist_del(slist_head_t *p_head, slist_node_t *p_node);

slist_node_t *slist_prev_get(slist_head_t *p_head, slist_node_t *p_pos);
slist_node_t *slist_next_get(slist_head_t *p_head, slist_node_t *p_pos);
slist_node_t *slist_tail_get(slist_head_t *p_head);
slist_node_t *slist_begin_get(slist_head_t *p_head);
slist_node_t *slist_end_get (slist_head_t *p_head);
int slist_foreach(slist_head_t *p_head,
                  slist_node_process_t pfn_node_process,
                  void *p_arg);

#endif

slist.c

#include "slist.h"
#include <stdlib.h>

int slist_init(slist_head_t *p_head)
{
    if (p_head == NULL)
    {
        return -1;
    }
    p_head->p_next = NULL;
    return 0;
}

int slist_add(slist_head_t *p_head, slist_node_t *p_pos, slist_node_t *p_node)
{
    p_node->p_next = p_pos->p_next;
    p_pos->p_next = p_node;
    return 0;
}

int slist_add_tail(slist_head_t *p_head, slist_node_t *p_node)
{
    slist_node_t *p_tmp = slist_tail_get(p_head); /* 找到尾结点 */
    return slist_add(p_head, p_tmp, p_node); /* 添加结点至尾结点之后 */
}

int slist_add_head(slist_head_t *p_head, slist_node_t *p_node)
{
    return slist_add(p_head, p_head, p_node); /* 添加结点至头结点之后 */
}

int slist_del(slist_head_t *p_head, slist_node_t *p_node)
{
    slist_node_t *p_prev = slist_prev_get(p_head, p_node); /* 找到待删除结点的上一个结点 */
    if (p_prev) 
    {
        p_prev->p_next = p_node->p_next;
        p_node->p_next = NULL;
        return 0;
    }
    return -1;
}

slist_node_t *slist_prev_get(slist_head_t *p_head, slist_node_t *p_pos)
{
    slist_node_t *p_tmp = p_head;
    while ((p_tmp != NULL) && (p_tmp->p_next != p_pos))
    {
        p_tmp = p_tmp->p_next;
    }
    return p_tmp;    
}

slist_node_t *slist_next_get(slist_head_t *p_head, slist_node_t *p_pos)
{
    if (p_pos) 
    {
        return p_pos->p_next;
    }
    return NULL;
}

slist_node_t *slist_tail_get(slist_head_t *p_head)
{
    return slist_prev_get(p_head, NULL);
}

slist_node_t *slist_begin_get(slist_head_t *p_head)
{
    return slist_next_get(p_head, p_head);
}

slist_node_t *slist_end_get(slist_head_t *p_head)
{
    return NULL;
}

int slist_foreach(slist_head_t *p_head,
                  slist_node_process_t pfn_node_process,
                  void *p_arg)
{
    slist_node_t *p_tmp, *p_end;
    int ret;

    if ((p_head == NULL) || (pfn_node_process == NULL))
    {
        return -1;
    }
    p_tmp = slist_begin_get(p_head);
    p_end = slist_end_get(p_head);
    while (p_tmp != p_end)
    {
        ret = pfn_node_process(p_arg, p_tmp);
        if (ret < 0) 
            return ret; /* 不再继续遍历 */
        p_tmp = slist_next_get(p_head, p_tmp); /* 继续下一个结点 */
    }
    return 0;
}

2.队列的实现

queue.h

#ifndef _QUEUE_H
#define _QUEUE_H

#include <stdbool.h>
#include <stddef.h>

typedef int queueElementT;
typedef struct queueCDT * queueADT;

queueADT newQueue(void);
void freeQueue(queueADT queue);
bool inQueue(queueADT queue, queueElementT value);
bool outQueue(queueADT queue, queueElementT *p_alue);
bool queueIsEmpty(queueADT queue);
bool queueIsFull(queueADT queue);
size_t getQueueLength(queueADT queue);

#endif

queue_slist.c

#include "queue.h"
#include <stdlib.h>
#include "slist.h"

#define MAXQSIZE 100
struct queueCDT 
{
    slist_head_t list_head; /* 链表头结点 */
    slist_node_t *p_rear; /* 指向队列的尾结点 */
};

typedef struct _queue_node_t
{
    slist_node_t node;
    queueElementT data;
} queue_node_t;

queueADT newQueue(void)
{
    queueADT queue;
    queue = (queueADT)malloc(sizeof(struct queueCDT));
    slist_init(&queue->list_head);
    queue->p_rear = &(queue->list_head);
    return queue;
}

void freeQueue(queueADT queue)
{
    while (!queueIsEmpty(queue))
    {
        slist_node_t *p_node = slist_begin_get(&queue -> list_head);
        slist_del(&queue -> list_head, p_node);
        free((queue_node_t *)p_node);
    }
    free(queue);
}

bool inQueue(queueADT queue, queueElementT value)
{
    if(queueIsFull(queue)) 
    {
        return false;
    }
    queue_node_t *p_node = (queue_node_t *)malloc(sizeof(queue_node_t));
    p_node -> data = value;
    slist_add(&queue->list_head, queue->p_rear,&(p_node->node));
    queue->p_rear = queue->p_rear->p_next;
    return true;
}

bool outQueue(queueADT queue, queueElementT *p_value)
{
    if(queueIsEmpty(queue)) 
    {
        return false;
    }
    slist_node_t *p_node = slist_begin_get(&queue -> list_head);
    *p_value = ((queue_node_t *)p_node) -> data;
    slist_del(&queue -> list_head, p_node);
    free(p_node);
    return true;
}

bool queueIsEmpty(queueADT queue)
{
    return (slist_begin_get(&queue -> list_head) == slist_end_get(&queue -> list_head));
}

bool queueIsFull(queueADT queue)
{
    /* 链队列不会满 */
    return false;
}

static int _numElems_node(void *p_arg, slist_node_t *p_node)
{
    (*(size_t *)p_arg)++;
    return 0;
}

size_t getQueueLength(queueADT queue)
{
    size_t count = 0;
    slist_foreach(&queue->list_head, _numElems_node, &count);
    return count;
}

3.Demo

main.c

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

int main(int argc, char *argv[])
{
    queueADT queue;
    int temp, i;

    queue = newQueue();
    for(i = 0; i < 16; i++) 
    {
        inQueue(queue, i);
    }
    printf("The length is %d
", (int)getQueueLength(queue));
    while (!queueIsEmpty(queue)) 
    {
        outQueue(queue, &temp);
        printf("%d ", temp);
    }
    freeQueue(queue);
    return 0;
}