队列的基本操作（入队、出队、清空……）

队列的基本操作（入队、出队、清空……）

SqQue.h

#ifndef __SQQUE_H__
#define __SQQUE_h__
typedef int element;
typedef struct SqQue
{
    element *data;			//动态定义存储空间大小
    int max_len;			//存放最多的存储元素个数
    int now_len;			//当前存放的元素个数
    int rear;				//队尾下标，下一个入队元素的下标
    int front;				//队头下标，下一个出队元素的下标
}SqQue;

/*
	功能：初始化顺序队列
	参数：@maxl：最大长度
*/
SqQue *InitSqQue(int maxl);

/*
	功能：清空顺序栈
	参数：头指针
*/
void clearSqQue(SqQue *q);

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q);

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisempty(SqQue *q);

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelength(SqQue *q);

/*
	功能：入队
	参数：@*q：头指针；@x：入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q);

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQue(SqQue *q,element *x);

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x);
#endif

SqQue.c

#include<stdio.h>
#include<stdlib.h>
#include "SqQue.c"

/*
	功能：初始化顺序队列
	参数：@maxl：最大长度
*/
SqQue *InitSqQue(int maxl)
{
    SqQue *q = malloc(sizeof(*q));
    q->data = malloc(sizeof(element) * maxl);
    q->max_len = maxl;
    q->now_len = 0;
    q->rear = 0;
    q->front = 0;
    return q;
} 

/*
	功能：清空顺序队列
	参数：头指针
*/
void clearSqQue(SqQue *q)
{
    if(q == NULL)
    {
        return;
    }
    q->now_len = 0;
    q->rear = 0;
    q->front = 0;
    return;
}

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q)
{
    if(q == NULL)
    {
        return;
    }
    free(q->data);
    free(q);
    return;
}

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisempty(SqQue *q)
{
    if(q == NULL || q->now_len == 0)
    {
        return 1;
    }
    return 0;
}

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelength(SqQue *q)
{
    if(q == NULL || q->now_len == 0)
    {
        return 0;
    }
    return q->now_len;
}

/*
	功能：入队
	参数：@*q：头指针；@x：入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q)
{
    if(q == NULL || q->now_len == q->max_len)
    {
        return 0;
    }
    q->data[q->rear++] = x;
    q->rear = q->rear % q->max_len;
    q->now_len++;
    return 1;
}

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQue(SqQue *q,element *x)
{
    if(q == NULL || q->now_len == 0)
    {
        return 0;
    }
    *x = q->data[q->front++];
    printf("出队元素为：%d\n",*x);
    q->front = q->front % q->max_len;
    q->now_len--;
    return1;
}

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x)
{
	if(q == NULL || q->now_len == 0)
	{
		return 0;
	}
	*x = q->data[q->front];
	printf("队头元素为：%d\n",*x);
	return 1;
}

main.c

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

int main()
{
	int maxl,x,i;
	printf("请输入最大长度：\n");
	scanf("%d",&maxl);
	SqQue *q = InitSqQue(maxl);
	printf("请输入队列元素：\n");
	for(i = 0;i < maxl;i++)
	{
		scanf("%d",&x);
		SqQuein(q,x);
	}
	SqQueout(q,&x);
	getSqQue(q,&x);
	int m = SqQueisEmpty(q);
	printf("%d\n",m);
	clearSqQue(q);
	int n = SqQueisEmpty(q);
	printf("%d\n",n);
	
	return 0;
}

链式队列

LinkQue.h

#ifndef __LINKQUE_h__
#define __LINKQUE_h__

typedef int element;

typedef struct QNode			//数据结点
{
	element data;
	struct QNode *next;
	struct QNode *prev;
	
}QNode;

typedef struct Qlink			//头结点
{
	QNode *front;
	QNode *rear;
	element Nodenum;
}LinkQue;

/*
	功能：初始化链式队列
	返回值：头指针
*/
LinkQue *InitLinkQue(void);

/*
	功能：清空链式队列
	参数：头指针
*/
void clearLinkQue(LinkQue *q);

/*
	功能：销毁链式队列
	参数：头指针
*/
void destroyLinkQue(LinkQue *q);

/*
	功能：判断链式队列是否为空
	参数：头指针
*/
int LinkQueisempty(LinkQue *q);

/*
	功能：求链式队列的长度
	参数：头指针
	返回值：队列长度
*/
int LinkQueLenth(LinkQue *q);

/*
	功能：入队
	参数：@q：头指针；@x：入队的数据
	返回值：1--成功；0--失败
*/
int LinkQuein(LinkQue *q,element x);

/*
	功能：出队
	参数：@q：头指针；@*x：出队数据存放位置
	返回值：1--成功；0--失败
*/
int LinkQueout(LinkQue *q,element *e);

/*
	功能：获取队头元素
	参数：@q：头指针；@*x：数据存放位置
	返回值：1--成功；0--失败
*/
int GetHead(LinkQue *q, element *e);

#endif#ifndef __SQQUE_H__
#define __SQQUE_H__
typedef int element;

typedef struct SqQue
{
	element *data;			//动态定义存储空间大小
	int max_len;		//存放最多的元素个数
	int now_len;		//当前的元素个数
	int rear;			//队尾下标，下一个入队元素的下标
	int front;     		//队头下标，下一个出队元素的下标
	
}SqQue;

/*
	功能：初始化队列
	参数：@maxl：最大长度
	返回值：顺序队列的头指针
*/
SqQue *InitSqQue(int maxl);

/*
	功能：清空顺序队列
	参数：头指针
*/
void clearSqQue(SqQue *q);

/*
	功能：销毁顺序队列
	参数：头指针
*/
void destroySqQue(SqQue *q);

/*
	功能：判断顺序队列是否为空
	参数：头指针
	返回值：1--成功；0--失败
*/
int SqQueisEmpty(SqQue *q);

/*
	功能：求队列的长度
	参数：头指针
	返回值：队列的长度
*/
int SqQuelenth(SqQue *q);

/*
	功能：入队
	参数：头指针;入队的元素
	返回值：1--成功；0--失败
*/
int SqQuein(SqQue *q,element x);

/*
	功能：出队
	参数：头指针;存放出队元素
	返回值：1--成功；0--失败
*/
int SqQueout(SqQue *q,element *x);

/*
	功能：获取队头元素，但不出队
	参数：头指针;存放队头元素
	返回值：1--成功；0--失败
*/
int getSqQue(SqQue *q,element *x);



#endif

LinkQue.c

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

/*
	功能：初始化链式队列
	返回值：头指针
*/
LinkQue *InitLinkQue(void)
{
	LinkQue * q = malloc(sizeof(*q));
	q->front = NULL;
	q->rear = NULL;
	q->Nodenum = 0;
	return q;
}

/*
	功能：清空链式队列
	参数：头指针
*/
void clearLinkQue(LinkQue *q)
{
	if(q == NULL)
	{
		return;
	}
	QNode *p = q->front;
	while(p)
	{
		q->front = p->next;
		if(p->next)
		{
			p->next->prev = NULL;
		}
		p->next = NULL;
		free(p);
		p = q->front;
	}
	q->rear = NULL;
	q->Nodenum = 0;
	return;
}

/*
	功能：销毁链式队列
	参数：头指针
*/
void destroyLinkQue(LinkQue *q)
{
	if(q == NULL)
	{
		return;
	}
	clearLinkQue(q);
	free(q);
}

/*
	功能：判断链式队列是否为空
	参数：头指针
*/
int LinkQueisempty(LinkQue *q)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 1;
	}
	return 0;
}

/*
	功能：求链式队列的长度
	参数：头指针
	返回值：队列长度
*/
int LinkQueLenth(LinkQue *q)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 0;
	}
	return q->Nodenum;
}

/*
	功能：入队
	参数：@q：头指针；@x：入队的数据
	返回值：1--成功；0--失败
*/
int LinkQuein(LinkQue *q,element x)
{
	if(q == NULL)
	{
		return 0;
	}
	QNode *p = malloc(sizeof(*p));
	p->data = x;
	p->next = NULL;
	p->prev = NULL;
	if(q->front == NULL)
	{
		q->front = p;
		q->rear = p;
	}
	else
	{
		q->rear->next = p;
		p->prev = q->rear;
		q->rear = p;
	}
	q->Nodenum++;
	return 1;
}

/*
	功能：出队
	参数：@q：头指针；@*x：出队数据存放位置
	返回值：1--成功；0--失败
*/
int LinkQueout(LinkQue *q,element *e)
{
	if(q == NULL || q->Nodenum == 0)
	{
		return 0;
	}
	*e = q->front->data;
	printf("出队元素：%d\n",*e);
	QNode *p = q->front;
	q->front = p->next;
	if(p->next)
	{
		p->next->prev = NULL;
		p->next = NULL;
		free(p);
	}	
	else
	{
		q->rear = NULL;
		free(p);
	}
	q->Nodenum--;
	return 1;
}

/*
	功能：获取队头元素
	参数：@q：头指针；@*x：数据存放位置
	返回值：1--成功；0--失败
*/
int GetHead(LinkQue *q, element *e)
{
	if (q == NULL || q->front == NULL)
	{
		return 0;
	}

	*e = q->front->data; 
	printf("队首元素：%d\n",*e);

	return 1;
}

main.c

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

int main()
{
	element x,e;
	LinkQue *q = InitLinkQue();
	printf("请输入入队数据：\n");
	while(1)
	{
		scanf("%d",&x);
		if(x == 0)
		{
			break;
		}
		LinkQuein(q,x);
	}
	GetHead(q,&x);
	int n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	LinkQueout(q,&x);
	n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	GetHead(q,&x);
	int m = LinkQueisempty(q);
	printf("%d\n",m);
	clearLinkQue(q);
	n = LinkQueLenth(q);
	printf("长度是：%d\n",n);
	m = LinkQueisempty(q);
	printf("%d\n",m);
	return 0;
}