0x00数据结构——C语言实现（队列）

0x00数据结构——C语言实现（队列）

实现

/*
使用队列时，插入在一端进行而删除在另一端进行
队列的基本操作是入队（enqueue），它是在表的末端（队尾（rear））插入一个元素，
还有出队（dequeue），它是删除（或返回）在表的开头（队头（front））的元素。

    dequeue(Q)                      enqueue(Q,X)
                =================
                |               |
<---------------|   queue Q     |<-----------------
                |               |
                =================


利用
functions:
    创建一个空的队列；
    判断队列是不是空的；
    判断队列是不是满的；
    释放队列所占用的空间；
    将队列置空；
    出队；
    获得队头元素；
    入队；
    输出；

*/
#ifndef QUEUE_H
#define QUEUE_H


typedef enum {
    false = 0,
    true
} BOOL;

struct node;
typedef struct node node;
typedef node *pos;
typedef node *queue;

//  创建一个空的队列；
queue create_queue(void);

//  判断队列是不是空的；
BOOL is_empty(queue Q);

//  判断队列是不是满的；
BOOL is_full(queue Q);

//  将队列置空；
BOOL set_empty(queue Q);

//  释放队列所占用的空间；
BOOL delete_queue(queue *Q);

//  出队；
int dequeue(queue Q);

//  获得队头元素；
int front_queue(queue Q);

//  入队；
void enqueue(queue Q, int x);

//  输出；
void print_queue(queue Q);

#endif

#include 
#include 
#include "queue.h"

#define MAXQUEUE 100

struct node {
    int val;
    struct node *next;
    struct node *pre;
};

//struct node;
//typedef struct node node;
//typedef node *pos;
//typedef node *queue;

//  创建一个空的队列；
queue create_queue(void)
{
    queue tmp = (queue)malloc(sizeof(node));
    tmp->val = 0;
    tmp->next = NULL;//附加头节点的next域指向队头
    tmp->pre = NULL;//附加头节点的pre域指向队尾
    return tmp;
}

//  判断队列是不是空的；
BOOL is_empty(queue Q)
{
    return (Q->val == 0);
}

//  判断队列是不是满的；
BOOL is_full(queue Q)
{
    return (Q->val == MAXQUEUE);
}

//  将队列置空；
BOOL set_empty(queue Q)
{
    node *tmp = Q->next;
    while(tmp!=NULL) {
        (tmp->pre)->next = tmp->next;
        (tmp->next)->pre = tmp->pre;
        free(tmp);
        (Q->val)--;
        tmp = Q->next;
    }

    return true;
}

//  释放队列所占用的空间；
BOOL delete_queue(queue *Q)
{
    set_empty(*Q);
    free(*Q);
    *Q = NULL;
    return true;
}

//  出队；
int dequeue(queue Q)
{
    if(is_empty(Q)) {
        printf("Q is empty\n");
        return -1;
    }
    node *tmp = Q->next;
    int r = tmp->val;
    Q->next = tmp->next;
    if(tmp->next != NULL) {
        (tmp->next)->pre = NULL;
    }
    (Q->val)--;
    return r;
}


//  获得队头元素；
int front_queue(queue Q)
{
    return (Q->next)->val;
}

//  入队；
void enqueue(queue Q, int x)
{
    if(is_full(Q)) {
        printf("Q is full\n");
    }
    node *tmp = (queue)malloc(sizeof(node));
    tmp->val = x;
    if(Q->pre != NULL) {
        (Q->pre)->next = tmp;
        tmp->pre = (Q->pre);
        tmp->next = NULL;
        Q->pre = tmp;
    } else {
        tmp->pre = NULL;
        tmp->next  =NULL;
        Q->pre = tmp;
        Q->next = tmp;
    }       
    (Q->val)++;
}

//  输出；
void print_queue(queue Q)
{
    node *tmp = Q->next;
    if(tmp == NULL) {
        printf("->");
    } else {
        while(tmp != NULL) {
            printf("->%d", tmp->val);
            tmp = tmp->next;
        }
    }
    printf("\n");
}

实验

#include 
#include 
#include "queue.h"


int main()
{
    queue Q;
    int i;
    Q = create_queue();
    for(i = 0; i<10; i++) {
        print_queue(Q);
        enqueue(Q, i);

    }


    while(!is_empty(Q)) {
        dequeue(Q);
        print_queue(Q);
    }


    return 0;
}

实验结果

->
->0
->0->1
->0->1->2
->0->1->2->3
->0->1->2->3->4
->0->1->2->3->4->5
->0->1->2->3->4->5->6
->0->1->2->3->4->5->6->7
->0->1->2->3->4->5->6->7->8
->1->2->3->4->5->6->7->8->9
->2->3->4->5->6->7->8->9
->3->4->5->6->7->8->9
->4->5->6->7->8->9
->5->6->7->8->9
->6->7->8->9
->7->8->9
->8->9
->9
->
Time elapsed: 000:00:031
Press any key to continue