数据结构---线性表(链式队列)

LinkQueue.h

#ifndef __LINKQUEUE__H_
#define __LINKQUEUE__H_

//一些库函数的头文件包含
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
 
//自定义bool
typedef int Boolean;
 
//定义函数返回状态
typedef int Status;
 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef struct Node
{
	int data;
	struct Node *next;
}LNode,*PNode;

typedef struct queue
{
    PNode front;  //队列头指针
    PNode rear;   //队列尾指针
}Queue;

/* 初始化 */
Status init(Queue *que);

/* 销毁 */
Status destroy(Queue *que);

/* 重置 */
Status clear(Queue *que);

/* 判空 */
Boolean isEmpty(Queue que);

/* 获取已存元素的数量 */
int listLen(Queue que);

/* 获取队列头元素 */
Status getFront(Queue que, int *front);

/* 入队 */
Status inQue(Queue *que, int elem);

/* 出队 */
Status outQue(Queue *que, int *out_elem);

/* 根据给定关系改变元素的值 */
Status traverse(Queue que, void (*vi)(int *) );

#endif

LinkQueue.c

#include "LinkQueue.h"

/* 初始化 */
Status init(Queue *que)
{
    PNode p;
    p = (PNode)malloc(sizeof(LNode));
    if(!p)
    {
        printf("动态内存分配失败");
        exit(-1);
    }

    (*que).front = p;
    (*que).rear = p;
    (*que).front->next = NULL;
    return OK;
}

/* 销毁 */
Status destroy(Queue *que)
{
    PNode p;
    while(que->front)
    {
        p = que->front->next;
        free(que->front);
        que->front = p;
    }
    return OK;
}

/* 重置 */
Status clear(Queue *que)
{
    PNode q,p = que->front->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    
    que->rear = que->front;
    que->front->next = NULL;
    return OK;
}

/* 判空 */
Boolean isEmpty(Queue que)
{
    if(que.front == que.rear)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/* 获取已存元素的数量 */
int listLen(Queue que)
{
    int i = 0;
    PNode p = que.front->next;
    while(p)
    {
        i++;
        p = p->next;
    }
    
    return i;
}

/* 获取队列头元素 */
Status getFront(Queue que, int *front)
{
    PNode p = que.front->next;

    //if(!p)
    //{
    //    return ERROR;
    //}

    if(que.front == que.rear)
    {
        return ERROR;
    }

    *front = p->data;
    return OK;
    
}

/* 入队 ,在队尾插入元素*/
Status inQue(Queue *que, int elem)
{
    PNode p = (PNode)malloc(sizeof(LNode));
    p->data = elem;
    p->next = NULL;

    que->rear->next = p; //把尾结点的指针域设置为新结点
    que->rear = p;  //把队列尾指针设置为新结点
    return OK;
}

/* 出队 ，在队头删除元素*/
Status outQue(Queue *que, int *out_elem)
{
    PNode p = que->front->next; //获取首结点
    if(que->front == que->rear)
    {
        return ERROR;
    }
    que->front->next = p->next; //吧头结点的指针域设置为首结点的下个结点
    *out_elem = p->data;

    if(que->rear == p)//如果只有一个有效结点
    {
        que->rear = que->front;
    }

    free(p);
    p = NULL;
    return OK;
}

/* 根据给定关系改变元素的值 */
Status traverse(Queue que, void (*vi)(int *) )
{
    PNode p = que.front->next;
    while(p)
    {
        vi(&p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}