3.Queue

sequeue

sequeue.h

typedef int datatype;

#define N 128

typedef struct {
	datatype data[N];
	int front;
	int	rear;
}sequeue;

sequeue* queue_create();
int enqueue(sequeue* sq, datatype x);
datatype dequeue(sequeue* sq);
int queue_empty(sequeue* sq);
int queue_full(sequeue* sq);
sequeue* queue_free(sequeue* sq);
int queue_clear(sequeue* sq);

sequeue.c

#include <stdio.h>
#include "sequeue.h"
#include <stdlib.h>
#include <string.h>
sequeue* queue_create()
{
	sequeue* sq;
	if ((sq = (sequeue*)malloc(sizeof(sequeue))) == NULL)
	{
		printf("malloc failed\n");
		return NULL;
	}
	memset(sq->data, 0, sizeof(sq->data));
	sq->front = sq->rear = 0;
	return sq;
}

int enqueue(sequeue* sq, datatype x)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return -1;
	}
	if ((sq->rear + 1) % N == sq->front)
	{
		printf("sequeue is full\n");
		return -1;
	}
	sq->data[sq->rear] = x;
	sq->rear = (sq->rear + 1) % N;
	return 0;
}
datatype dequeue(sequeue* sq)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return -1;
	}
	datatype ret;
	ret = sq->data[sq->front];
	sq->front = (sq->front + 1) % N;
	return ret;
}
int queue_empty(sequeue* sq)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return -1;
	}
	return sq->front == sq->rear ? 1 : 0;
}
int queue_full(sequeue* sq)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return -1;
	}
	return sq->front == (sq->rear + 1) % N ? 1 : 0;
}
sequeue* queue_free(sequeue* sq)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return NULL;
	}
	free(sq);
	sq = NULL;
	return sq;
}
int queue_clear(sequeue* sq)
{
	if (NULL == sq)
	{
		printf("sq is NULL");
		return -1;
	}
	sq->front = sq->rear = 0;
	return 0;
}

demo.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include "sequeue.h"
#include<stdlib.h>

void sequeue_test();

int main() {
	sequeue_test();
	return 0;
}

void sequeue_test() {
	sequeue* sq;
	if ((sq = queue_create()) == NULL) {
		printf("create queue failed\n");
		return;
	}
	enqueue(sq, 10);
	enqueue(sq, 20);
	enqueue(sq, 30);
	enqueue(sq, 40);
	enqueue(sq, 50);
	enqueue(sq, 60);

	printf("out:\n");
	while (!queue_empty(sq)) {
		printf("%d\t", dequeue(sq));
	}

}

linkqueue

linkqueue.h

typedef int datatype;

typedef struct node {
	datatype data;
	struct node* next;
}listnode, * linklist;

typedef struct {
	linklist front;
	linklist rear;
}linkqueue;

linkqueue* queue_create();
int enqueue(linkqueue* lq, datatype x);
datatype dequeue(linkqueue* lq);
int queue_empty(linkqueue* lq);
linkqueue* queue_clear(linkqueue* lq);
linkqueue* queue_free(linkqueue* lq);
int queue_show(linkqueue* lq);

char queue_dequeue_char(linkqueue* lq);

linkqueue.c

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

linkqueue* queue_create() {
	linkqueue* lq;
	if ((lq = (linkqueue*)malloc(sizeof(linkqueue))) == NULL) {
		printf("malloc linkqueue failed\n");
		return NULL;
	}
	lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
	if (lq->front == NULL) {
		printf("malloc node failed\n");
		return NULL;
	}
	lq->front->data = 0;
	lq->front->next = NULL;
	return lq;
}
int enqueue(linkqueue* lq, datatype x) {
	linklist p;
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}
	if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc node failed\n");
		return -1;
	}
	p->data = x;
	p->next = NULL;

	lq->rear->next = p;
	lq->rear = p;
	return 0;
}
datatype dequeue(linkqueue* lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}
	linklist p;
	p = lq->front;
	lq->front = p->next;
	free(p);
	return lq->front->data;
}
int queue_empty(linkqueue* lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}
	return lq->front == lq->rear ? 1 : 0;
}


linkqueue* queue_clear(linkqueue* lq) {
	linklist p;
	if (lq == NULL) {
		printf("lq is NULL\n");
		return NULL;
	}
	/*
	while(lq->front->next){
		p = lq->front;
		lq->front = p->next;
		printf("clear free:%d\n",p->data);
		free(p);
		p = NULL;
	}*/
	while (!queue_empty(lq)) {
		p = lq->front;
		lq->front = p->next;
		printf("clear free:%d\n", p->data);
		free(p);
		p = NULL;
	}
	return lq;
}

linkqueue* queue_free(linkqueue* lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return NULL;
	}
	linklist p;

	while (lq->front) {
		//printf("lq->front:%p\n",lq->front);
		p = lq->front;
		lq->front = p->next;
		printf("free:%d\n", p->data);
		free(p);
	}
	free(lq);
	lq = NULL;
	return lq;
}

int queue_show(linkqueue* lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return -1;
	}
	printf("dequeue:\n");
	while (!queue_empty(lq)) {
		printf("%d\t", dequeue(lq));
	}
	puts("");
	return 1;
}

char queue_dequeue_char(linkqueue* lq) {
	if (lq == NULL) {
		printf("lq is NULL\n");
		return '\0';
	}
	linklist p;
	p = lq->front;
	lq->front = p->next;
	free(p);
	return (char)lq->front->data;
}

demo.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include "linkqueue.h"
#include<string.h>

void test_create();
void test_clear();
void test_dequeue_char();
int main() {
	test_dequeue_char();
	return 0;
}

void test_dequeue_char() {
	linkqueue* lq;
	int n;
	lq = queue_create();
	if (lq == NULL) {
		printf("lq is NULL\n");
		return;
	}
	printf("please input:\n");
	while (1) {
        char ch;
        scanf("%c", &ch);
        //是否是字符
        if(isalpha(ch)){
            dequeue(lp);
        }
		//是否是数字
        if(isdigit(ch)){
            n = (int)(ch - '0');
            enqueue(lq, n);
        }
		
		if (ch == '?') {
			break;
		}
		
	}

	printf("dequeue:\n");
	while (!queue_empty(lq)) {
		printf("%c\t", queue_dequeue_char(lq));
	}
	puts("");
	/*
	
	please input:
	65
	66
	67
	-1
	dequeue:
	A       B       C
	*/
}

void test_clear() {
	linkqueue* lq;
	lq = queue_create();
	if (lq == NULL) {
		printf("lq is NULL\n");
		return;
	}
	enqueue(lq, 10);
	enqueue(lq, 20);
	enqueue(lq, 30);
	enqueue(lq, 40);

	//queue_show(lq);
	lq = queue_clear(lq);
	queue_show(lq);

}

void test_create() {
	linkqueue* lq;
	lq = queue_create();
	if (lq == NULL) {
		printf("lq is NULL\n");
		return;
	}
	enqueue(lq, 10);
	enqueue(lq, 20);
	enqueue(lq, 30);
	enqueue(lq, 40);

	//queue_show(lq);
	lq = queue_free(lq);
	queue_show(lq);

}

makefile

CC = gcc

SRC = $(wildcard *.c)
OBJ = $(patsubst %.c, %.o, $(SRC))

test:$(SRC)
	$(CC)	$^	-o	$@	-Wall

.PHONY:clean
clean:
	rm	./*.o