队列--顺序表实现和单向链表实现

顺序表实现

头文件

#ifndef CPROJECT_QUEUE_H
#define CPROJECT_QUEUE_H

#include <stdlib.h>
#include <stdio.h>

typedef int data_t;

typedef struct queue{
    data_t *data;
    int last;
    int count;
}queue_t;

queue_t *queue_create(int m);

int is_empty_queue(queue_t *q);

int is_full_queue(queue_t *q);

int queue_length(queue_t *q);

void queue_push(queue_t  *q, data_t x);

data_t queue_pop(queue_t *q);

void queue_destory(queue_t **q);

void queue_show(queue_t *q);

void test_queue();

#endif

源文件

#include "../header/queue.h"

queue_t *queue_create(int m){

    queue_t *q = (queue_t *) malloc(sizeof(queue_t ));
    q->data = (data_t *) malloc(sizeof(data_t )*m);
    q->last = -1;
    q->count = m;

    return q;
}

int is_empty_queue(queue_t *q){
    return q->last == -1;
}

int is_full_queue(queue_t *q){
    return q->last == (q->count - 1);
}

int queue_length(queue_t *q){
    return (q->last + 1);
}

void queue_show(queue_t *q){

    for (int i = 0; i <= q->last; ++i) {
        printf("%d ",q->data[i]);
    }
    printf("\n");
}

void queue_push(queue_t  *q, data_t x){

    if(is_full_queue(q))
        return;
    for (int i = q->last; i >= 0; --i) {
        q->data[i+1] = q->data[i];
    }
    q->data[0] = x;

    q->last += 1;
}

data_t queue_pop(queue_t *q){
    data_t temp = q->data[q->last];
    q->last -= 1;
    return temp;
}

void queue_destory(queue_t **q){
    free((*q)->data);
    free(q);
    q = NULL;
}

void test_queue(){
    queue_t *q = queue_create(20);
    for (int i = 1; i <= 10; ++i) {
        queue_push(q,i);
    }
    queue_show(q);

    printf("out:%d\n", queue_pop(q));

    queue_show(q);
}

单链表实现

头文件

#ifndef CPROJECT_QUEUE_LINK_H
#define CPROJECT_QUEUE_LINK_H

#include <stdio.h>
#include <stdlib.h>

typedef int data_t;

typedef struct Qnode{
    data_t data;
    struct Qnode *next;
}qnode;

typedef struct lqueue{
    qnode *tail;
    qnode *head;
}lqueue_t;

qnode *qnode_create(data_t x);

lqueue_t *lqueue_create();

int is_empty_lqueue(lqueue_t *lq);

int lqueue_length(lqueue_t *lq);

void lqueue_push(lqueue_t  *lq, data_t x);

data_t lqueue_pop(lqueue_t *lq);

void lqueue_show(lqueue_t *lq);

void test_lqueue();

#endif

源文件

#include "../header/queue_link.h"

qnode *qnode_create(data_t x){
    qnode *qn = (qnode *) malloc(sizeof(qnode));
    qn->next = NULL;
    qn->data = x;
    return qn;
}
//head出，tail进
lqueue_t *lqueue_create(){

    lqueue_t *lq = (lqueue_t *) malloc(sizeof(lqueue_t ));

    lq->tail = NULL;
    lq->head = NULL;

    return  lq;
}

int is_empty_lqueue(lqueue_t *lq){
    return lq->head == NULL;
}

int lqueue_length(lqueue_t *lq){
    int count = 0;
    qnode *p = lq->head;
    while (p != NULL){
        count++;
        p = p->next;
    }
    return count;
}

void lqueue_push(lqueue_t  *lq, data_t x){
    qnode *new = (qnode *) malloc(sizeof(qnode));
    new->next = NULL;
    new->data = x;

    //判断是否为空队列，为空则将tail和head都指向new
    if(is_empty_lqueue(lq))
        lq->head = lq->tail = new;
    else{
        //不是则插入在tail后面，然后tail往后移一个位置
        lq->tail->next = new;
        lq->tail = lq->tail->next;
    }
}
//把当前head出队，head往后移一个位置
data_t lqueue_pop(lqueue_t *lq){

    data_t val;

    if(is_empty_lqueue(lq))
        return -1;
    if(lq->head == lq->tail){   //只有一个节点
        val = lq->head->data;
        free(lq->head);//tail和head指向同一片区域，free一个即可
        lq->head = lq->tail = NULL;
    } else{     //有多个节点,把当前head出队，head往后移一个位置
        qnode *temp = lq->head;
        val = temp->data;
        lq->head = lq->head->next;
        free(temp);
    }

    return val;
}

void lqueue_show(lqueue_t *lq){
    qnode *p = lq->head;
    while (p != NULL){
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}

void test_lqueue(){
    lqueue_t *lq = lqueue_create();
    for (int i = 0; i < 10; ++i) {
        lqueue_push(lq,i);
    }
    lqueue_show(lq);

    printf("out:%d\n", lqueue_pop(lq));
    lqueue_show(lq);
}