环形队列的链式实现（原创）

程序是用codeblock写的，中间碰到了一个又一个的问题，都最终解决了。这个结构可以作为所有结构体的实现的一个模式。写写这些程序可以不断让自己更加深入认识指针，更加熟悉指针的各种使用。经常锻炼C基础，心里写程序更有底哈哈

链式环形队列实现/* ** 链式环形队列实现 */



#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>



typedef int Queue_Type;



// 定义队列节点结构

typedef struct CQUEUE_NODE

{

    Queue_Type value;

    struct CQUEUE_NODE *next;

}QNode, *PNode;



// 定义队列结构

typedef struct CQUEUE

{

    unsigned int size;

    PNode front, retail;

}LQueue;





//创建环形队列

void Create_Queue(LQueue *L, int n)

{

    PNode front = (PNode)malloc(sizeof(QNode));

    PNode retail = (PNode)malloc(sizeof(QNode));

    if(front == NULL || retail == NULL)

    exit(1);



    scanf("%d", &front->value);

    front->next = NULL;



    // 只有一个节点的时候，头尾指向同一个点

    retail = front;



    // 多个点情况

    int i;

    for(i = 1; i < n; i++)

    {

        PNode p = (PNode)malloc(sizeof(QNode));

        if(p == NULL)

        exit(1);

        scanf("%d", &p->value);

        retail->next = p;

        retail = p;

    }

    // 结束后，尾节点指向头节点

    retail->next = front;



    L->front = (PNode)malloc(sizeof(QNode));

    L->retail = (PNode)malloc(sizeof(QNode));

    if(L->front == NULL || L->retail == NULL)

    exit(1);

    L->front = front;

    L->retail = retail;

    L->size = n;

}



// 销毁队列

void Destory_Queue(LQueue *L)

{

    // 如果队列为空

    if(L->front == NULL)

    exit(1);



    // 这里注意必须重新申请一个节点

    // 直接使用L->retail->next会有类型不能识别的错误

    PNode p = (PNode)malloc(sizeof(QNode));

    if(p == NULL)

    exit(1);

    p = L->front;

    int size = L->size;



    // 队列是多个节点情况

    while(size != 0)

    {

        L->front = p->next;

        free(p);

        p = L->front;

        size--;

    }



    // 这里一定要记得处理

    // 将front retail指向NULL 在上面的处理过程中，只是free并没有指向NULL

    // 如果不指向NULL, front,retail将是野指针

    // 还要记得将L->size重新赋值，上面size只是读取size，并不改变size的值

    L->front = NULL;

    L->retail = NULL;

    L->size = size;

}



// 入列操作 在尾节点插入

void Enqueue(LQueue *L, Queue_Type value)

{

    PNode p = (PNode)malloc(sizeof(QNode));

    if(p == NULL)

    exit(1);

    p->value = value;

    int size = L->size;



    //如果队列是个空队列

    if(size == 0)

    {

        L->front = (PNode)malloc(sizeof(QNode));

        L->retail = (PNode)malloc(sizeof(QNode));

        L->front = p;

        L->retail = p;

        p->next = NULL;

        size ++;

    }



    // 如果队列不是空队列

    // 头节点倒是没有必要重新开辟空间

    PNode p1 = (PNode)malloc(sizeof(QNode));

    if(p1 == NULL)

    exit(1);

    p1 = L->retail;

    p1->next = p;

    p->next = L->front;

    L->retail = p; //这里没发现啊，害我找了很久

    size++;

    L->size = size;

}



// 出列操作

Queue_Type Dequeue(LQueue *L)

{

    int size = L->size;

    Queue_Type n;



    //如果队列为空

    if(size == 0)

    {

        printf("The queue is empty.\n");

        exit(1);

    }



    PNode p = (PNode)malloc(sizeof(QNode));

    if(p == NULL)

    exit(1);

    p = L->front;



    //如果队列只有一个节点

    if(size == 1)

    {

        n = p->value;

        free(p);

        L->front = L->retail = NULL;

        p = NULL;

        size--;

        L->size = size;

        return n;

    }



    if(size == 2)

    {

        n = p->value;

        L->front = L->retail;

        free(p);

        p = NULL;

        size--;

        L->size = size;

        return n;

    }



    // 头节点倒是没有必要重新开辟空间

    PNode p1 = (PNode)malloc(sizeof(QNode));

    if(p1 == NULL)

    exit(1);

    p1 = L->retail;



    n = p->value;

    L->front = p->next;

    p1->next = L->front;

    free(p);

    p = NULL;

    size--;

    L->size = size;

    return n;

}



// 判断队列是否为空

bool Is_Empty(LQueue L)

{

    if(L.size == 0)

    return false;

    else

    return true;

}



// 打印队列

void Print_Queue(LQueue L)

{

    // 如果队列为空

    if(L.size == 0)

    {

        printf("The size of the queue is: %d\n", L.size);

        exit(1);

    }



    printf("The size of the queue is: %d\n", L.size);

    printf("The following are the elements of the queue:\n");



    PNode p = (PNode)malloc(sizeof(QNode));

    if(p == NULL)

    exit(1);

    p = L.front;



    while(p != L.retail)

    {

        printf("%d\n", p->value);

        p = p->next;

    }

    if(p == L.retail)

    {

        printf("%d\n", p->value);

    }

}



int main()

{

    LQueue L;

    int n;

    printf("Input the number of the nodes of the queue:\n");

    scanf("%d", &n);

    printf("-------------------------------------------\n");

    Create_Queue(&L, n);

    printf("-------------------------------------------\n");

    Print_Queue(L);

    printf("-------------------------------------------\n");

    printf("Enqueue a node:\n");

    int n1, n2,n3;

    scanf("%d", &n1);

    Enqueue(&L, n1);

    printf("-------------------------------------------\n");

    Print_Queue(L);

    printf("Dequeue one node -------------------------\n");

    n2 = Dequeue(&L);

    printf("Node1 is %d\n",n2);

    Print_Queue(L);

    printf("Dequeue another node -------------------------\n");

    n3 =Dequeue(&L);

    printf("Node2 is %d\n",n3);

    Print_Queue(L);

    printf("-------------------------------------------\n");

    printf("Destory the queue---------------------------\n");

    Destory_Queue(&L);

    Print_Queue(L);

    return 0;

}
 
 
 

关于指针可能碰到的问题，在注释里差不多都说明了。

需要特别注意几个问题：

一，结构作为参数传递。这个传递方式也是和其他一样的，当需要改变传入参数的值的时候，用地址传递，使用指针参数。参数的传递类似于一般的int了，使用结构体指针就行。

二，结构体参数值传递和地址传递的调用方式的不同。结构体参数如果是以普通值传递进入参数，使用结构体.成员来访问。如果是以地址传递，也就是传入的是指针参数，就是结构体->成员来访问。这个就是结构体和结构体指针访问数据成员的差异。

三，像队列这种包含头尾队列点的结构体，在初始化的时候，要为每个一个指针结构申请空间，也就是里面的

L->front = (PNode)malloc(sizeof(QNode));
L->retail = (PNode)malloc(sizeof(QNode));

四，在取结构体成员指针指向的数据的时候，不要使用  结构体指针->指针成员->指针成员指向的数据。 这样多个"->"连接会导致编译不能识别“结构体指针->指针成员”这个指针类型，会报错的。相应的处理方法是申请一个指针指向它就行。然后操作这个指针。

五， 对于特定临界点情况的处理要慎重，比如队列数据点为0，1，2这几个情况对于环形队列是不同的，需要额外注意。

具体的算法，上面的程序里面都有了。都经过了简单的测试，应该没什么问题。

 

顺道说下CODEBLOCK的debug，到现在我不太知道，怎样使用，几次加入Watch变量都没反应囧，出错了，只能一个一个自己分析。

注：这个问题后来查了相关的论坛，原来codeblock不允许项目路径有空格和中文字符导致。