一、顺序队列

0、结构

typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

/* 循环队列的顺序存储结构 */
typedef struct {
    QElemType data[MAXSIZE];
    int front;        /* 头指针 */
    int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
} SqQueue;

1、创建

Status InitQueue(SqQueue *Q) {
    Q->front = 0;
    Q->rear = 0;
    return OK;
}

2、置空

Status ClearQueue(SqQueue *Q) {
    Q->front = Q->rear = 0;
    return OK;
}

3、判空

Status QueueEmpty(SqQueue Q) {
    //队空标记
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

4、长度

int QueueLength(SqQueue Q) {
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

5、获取队头元素

Status GetHead(SqQueue Q, QElemType *e) {
    //队列已空
    if (Q.front == Q.rear)
        return ERROR;
    
    *e = Q.data[Q.front];
    return OK;
}

6、插入队尾元素

Status EnQueue(SqQueue *Q, QElemType e) {
    //队列已满
    if((Q->rear+1)%MAXSIZE == Q->front)
        return ERROR;
    
    //将元素e赋值给队尾
    Q->data[Q->rear] = e;
    
    //rear指针向后移动一位,若到最后则转到数组头部;
    Q->rear = (Q->rear+1)%MAXSIZE;
    
    return OK;
}

7、删除队头元素，并且用e带回

Status Pop(SqStack *S, SElemType *e){
    //空栈,则返回error;
    if (S->top == -1) {
        return ERROR;
    }
    
    //将要删除的栈顶元素赋值给e
    *e = S->data[S->top];
    //栈顶指针--;
    S->top--;
    
    return OK;
}

8、打印

Status QueueTraverse(SqQueue Q) {
    int i;
    i = Q.front;
    while ((i+Q.front) != Q.rear) {
        printf("%d   ",Q.data[i]);
        i = (i+1) % MAXSIZE;
    }
    printf("\n");
    return OK;
}

二、链队列

0、结构

typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

typedef struct QNode {   /* 结点结构 */
    QElemType data;
    struct QNode *next;
} QNode, *QueuePtr;

typedef struct {            /* 队列的链表结构 */
    QueuePtr front, rear; /* 队头、队尾指针 */
} LinkQueue;

1、创建

Status InitQueue(LinkQueue *Q) {
    
    //1. 头/尾指针都指向新生成的结点
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));

    //2.判断是否创建新结点成功与否
    if (!Q->front) {
        return ERROR;
    }

    //3.头结点的指针域置空
    Q->front->next = NULL;
    
    return OK;
}

2、销毁

Status DestoryQueue(LinkQueue *Q) {
    //遍历整个队列,销毁队列的每个结点
    while (Q->front) {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}

3、置空

Status ClearQueue(LinkQueue *Q) {
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    
    while (p) {
        q = p;
        p = p->next;
        free(q);
    }
    
    return OK;
}

4、判空

Status QueueEmpty(LinkQueue Q) {
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

5、长度

int QueueLength(LinkQueue Q) {
    int i= 0;
    QueuePtr p;
    p = Q.front;
    while (Q.rear != p) {
        i++;
        p = p->next;
    }
    return i;
}

6、获取队头元素

Status EnQueue(LinkQueue *Q, QElemType e) {
    //为入队元素分配结点空间,用指针s指向;
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    
    //判断是否分配成功
    if (!s) {
         return ERROR;
    }
    
    //将新结点s指定数据域.
    s->data = e;
    s->next = NULL;
    
    //将新结点插入到队尾
    Q->rear->next = s;
    
    //修改队尾指针
    Q->rear = s;
    
    return OK;
}

7、出队列

Status DeQueue(LinkQueue *Q, QElemType *e) {
    QueuePtr p;
    
    //判断队列是否为空;
    if (Q->front == Q->rear) {
        return ERROR;
    }
    
    //将要删除的队头结点暂时存储在p
    p = Q->front->next;
    
    //将要删除的队头结点的值赋值给e
    *e = p->data;
    
    //将原队列头结点的后继p->next 赋值给头结点后继
    Q->front->next = p ->next;
    
    //若队头就是队尾,则删除后将rear指向头结点.
    if(Q->rear == p) Q->rear = Q->front;
    
    free(p);
    
    return OK;
}

8、获取队头元素

Status GetHead(LinkQueue Q, QElemType *e) {
    //队列非空
    if (Q.front != Q.rear) {
        //返回队头元素的值,队头指针不变
        *e =  Q.front->next->data;
        return TRUE;
    }
    return  FALSE;
}

9、打印

Status QueueTraverse(LinkQueue Q) {
    QueuePtr p;
    p = Q.front->next;
    while (p) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}