数据结构学习——队列（链队列、循环队列）

文章目录

前言——队列
一、链队列
- 1.构建结构体
- 2.创建一个队列
- 3.跳出队列
- 4.进入队列
- 5.出队列
- 6.样例测试
- 7.完整代码
- 8.结果
二、循环队列
- 1.构造结构体
- 2.创造循环队列
- 3.进入队列
- 4.出队列
- 5.测试
- 6.完整代码
- 7.测试结果

前言——队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

一、链队列 1.构建结构体

typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQueue
{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

2.创建一个队列

LinkQueuePtr initQueue()
{
	LinkQueuePtr resultPtr; 
	resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));

	LinkNodePtr headerPtr;
	headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}

3.跳出队列

void outputLinkQueue(LinkQueuePtr paraQueuePtr)
{
	LinkNodePtr tempPtr; 
	tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) 
	{
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf("rn");
}

4.进入队列

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) 
{

	LinkNodePtr tempNodePtr;
	 
	tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	paraQueuePtr->rear->next = tempNodePtr;
	
	paraQueuePtr->rear = tempNodePtr;
}

5.出队列

int dequeue(LinkQueuePtr paraQueuePtr) 
{
	int resultValue;
	
	LinkNodePtr tempNodePtr;

	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		printf("此队列为空.rn");
		return -1;
	}

	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	if (paraQueuePtr->rear == tempNodePtr) 
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	
	tempNodePtr = NULL;

	return resultValue;
}

6.样例测试

void testLinkQueue()
{
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 20);
	enqueue(tempQueuePtr, 40);
	enqueue(tempQueuePtr, 60);
	enqueue(tempQueuePtr, 80);
	enqueue(tempQueuePtr, 100);

	outputLinkQueue(tempQueuePtr);

	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 15);
	outputLinkQueue(tempQueuePtr);
}

7.完整代码

#include 
#include 


typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQueue
{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

LinkQueuePtr initQueue()
{
	LinkQueuePtr resultPtr; 
	resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));

	LinkNodePtr headerPtr;
	headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}

void outputLinkQueue(LinkQueuePtr paraQueuePtr)
{
	LinkNodePtr tempPtr; 
	tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) 
	{
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf("rn");
}

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) 
{

	LinkNodePtr tempNodePtr;
	 
	tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	paraQueuePtr->rear->next = tempNodePtr;
	
	paraQueuePtr->rear = tempNodePtr;
}

int dequeue(LinkQueuePtr paraQueuePtr) 
{
	int resultValue;
	
	LinkNodePtr tempNodePtr;

	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		printf("此队列为空.rn");
		return -1;
	}

	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	if (paraQueuePtr->rear == tempNodePtr) 
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	
	tempNodePtr = NULL;

	return resultValue;
}

void testLinkQueue()
{
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 20);
	enqueue(tempQueuePtr, 40);
	enqueue(tempQueuePtr, 60);
	enqueue(tempQueuePtr, 80);
	enqueue(tempQueuePtr, 100);

	outputLinkQueue(tempQueuePtr);

	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 15);
	outputLinkQueue(tempQueuePtr);
}

int main()
{
	testLinkQueue();
	return 1;
}

8.结果

二、循环队列

循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用而再要进入队运算时，只需要存储空间的第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。

1.构造结构体

typedef struct CircleIntQueue
{
	int data[TOTAL_SPACE];
 
	int head;
 
	int tail;
}*CircleIntQueuePtr;

2.创造循环队列

CircleIntQueuePtr initQueue() 
{
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
 
	return resultPtr;
}

3.进入队列

void enqueue(CircleIntQueuePtr paraPtr, int paraValue) 
{
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) 
	{
		printf("队列已满.rn");
		return;
	} 
 
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}

4.出队列

int dequeue(CircleIntQueuePtr paraPtr) 
{
	int resultValue;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf("队列无元素.rn");
		return -1;
	}
 
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
 
	return resultValue;
}

5.测试

void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
	int i;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf("队列为空.");
		return;
	}
 
	printf("队列中的元素: ");
	for (i = paraPtr->head; i < paraPtr->tail; i++) 
	{
		printf("%d ", paraPtr->data[i % TOTAL_SPACE]);
		if(itail-1)
		{
			printf(",");
		}
	}
 
	printf("rn");
}

void testLinkQueue()
{
	int i;
	CircleIntQueuePtr tempPtr = initQueue();
	for (i=5;i < 12;i ++) 
	{
		enqueue(tempPtr, i);
	}
 
	outputLinkQueue(tempPtr);
 
	for (i = 0; i < 8; i ++) 
	{
		printf("dequeue gets %drn", dequeue(tempPtr));
	}
 
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}

6.完整代码

#include 
#include 
 
#define TOTAL_SPACE 5
 
typedef struct CircleIntQueue
{
	int data[TOTAL_SPACE];
 
	int head;
 
	int tail;
}*CircleIntQueuePtr;

CircleIntQueuePtr initQueue() 
{
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
 
	return resultPtr;
}

void enqueue(CircleIntQueuePtr paraPtr, int paraValue) 
{
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) 
	{
		printf("队列已满.rn");
		return;
	} 
 
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}

int dequeue(CircleIntQueuePtr paraPtr) 
{
	int resultValue;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf("队列无元素.rn");
		return -1;
	}
 
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
 
	return resultValue;
}

void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
	int i;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf("队列为空.");
		return;
	}
 
	printf("队列中的元素: ");
	for (i = paraPtr->head; i < paraPtr->tail; i++) 
	{
		printf("%d ", paraPtr->data[i % TOTAL_SPACE]);
		if(itail-1)
		{
			printf(",");
		}
	}
 
	printf("rn");
}

void testLinkQueue()
{
	int i;
	CircleIntQueuePtr tempPtr = initQueue();
	for (i=5;i < 12;i ++) 
	{
		enqueue(tempPtr, i);
	}
 
	outputLinkQueue(tempPtr);
 
	for (i = 0; i < 8; i ++) 
	{
		printf("dequeue gets %drn", dequeue(tempPtr));
	}
 
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}

int main(){
	testLinkQueue();
	return 1;
}

7.测试结果

数据结构学习——队列（链队列、循环队列）

C/C++/C#相关栏目本月热门文章