数据结构之队列

普通队列

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef struct Queue {
	int* qMem;
	int front;
	int tail;
	int curSize;
	int maxSize;
}QUEUE,*LPQUEUE;

LPQUEUE createQueue(int max) {
	//创建结构
	LPQUEUE queue = (LPQUEUE)malloc(sizeof(Queue));
	assert(queue);
	queue->qMem = (int*)malloc(sizeof(int) * max);
	queue->curSize = 0;
	queue->front = 0;
	queue->tail = 0;
	return queue;
}
int size(LPQUEUE queue) {
	return queue->curSize;
}
int empty(LPQUEUE queue) {
	return queue->curSize == 0;
}
//入队
void push(LPQUEUE queue, int data) {
	if (queue->curSize == queue->maxSize) {//伪溢出
		printf("队列已满!\n");
	}
	queue->qMem[queue->tail++] = data;
	queue->curSize++;
}

//获取对头元素
int front(LPQUEUE queue) {
	return queue->qMem[queue->front];
}
//出队
void pop(LPQUEUE queue) {
	if (queue->curSize == 0) {
		printf("队列为空，无法出队");
		return;
	}
	queue->front++;
	queue->curSize--;
}

int main() {
	LPQUEUE queue = createQueue(10);
	for (int i = 0; i < 10; i++) {
		push(queue, i);
	}
	while (!empty(queue)) {
		printf("%d ", front(queue));
		pop(queue);
	}

	return 0;
}

循环队列

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

typedef struct Queue {
	int* qMem;
	int front;
	int tail;
	int curSize;
	int maxSize;
}QUEUE,*LPQUEUE;

LPQUEUE createQueue(int max) {
	LPQUEUE queue = (LPQUEUE)malloc(sizeof(QUEUE));
	assert(queue);
	queue->maxSize = max;
	queue->qMem = (int*)malloc(max * sizeof(int));
	queue->curSize = 0;
	queue->front = 0;
	queue->tail = 0;
	return queue;
}
int size(LPQUEUE queue) {
	return queue->curSize;
}
int empty(LPQUEUE queue) {
	return queue->curSize == 0;
}
//入队函数
void push(LPQUEUE queue, int data) {
	if (queue->curSize == queue->maxSize) {
		printf("full queue\n");
		return;
	}
	//if(queue->front==(queue->tail+1)&max)
	queue->qMem[queue->tail] = data;
	queue->tail = (queue->tail + 1) % (queue->maxSize);
	queue->curSize++;
}
int front(LPQUEUE queue) {
	return queue->qMem[queue->front];
}
//出队函数
void pop(LPQUEUE queue) {
	if (queue->curSize == 0) {
		printf("empty queue!\n");
		return;
	}
	queue->front = (queue->front + 1) % (queue->maxSize);
	queue->curSize--;
}
int main() {
	LPQUEUE queue = createQueue(10);
	for (int i = 0; i < 10; i++) {
		push(queue, i);
	}
	while (!empty(queue)) {
		printf("%d ", front(queue));
		pop(queue);
	}
	push(queue, 100);
	printf("%d ", front(queue));

	return 0;
}

链式队列

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//节点基本构造
typedef struct Node {
	int data;
	struct Node* pNext;
}Node,*LPNODE,*LIST;
//创建节点
LPNODE createNode(int data) {
	LPNODE newNode = (LPNODE)malloc(sizeof(Node));
	assert(newNode);
	newNode->data = data;
	newNode->pNext = NULL;
	return newNode;
}
//队列基本构造
typedef struct Queue {
	int curSize;
	LPNODE frontNode;
	LPNODE tailNode;
}QUEUE,*LPQUEUE;
//创建队列
LPQUEUE createQueue() {
	LPQUEUE queue = (LPQUEUE)malloc(sizeof(Queue));
	assert(queue);
	queue->curSize = 0;
	queue->frontNode = NULL;
	queue->tailNode = NULL;
	return queue;
}
int size(LPQUEUE queue) {
	return queue->curSize;
}
int empty(LPQUEUE queue) {
	return queue->curSize == 0;
}
//入队
void push(LPQUEUE queue, int data) {
	LPNODE newNode = createNode(data);
	//入队实际就是无头链表的尾插入
	if (queue->curSize == 0) {
		queue->frontNode = newNode;
		//queue->tailNode = newNode;
		//queue->curSize++;
	}
	else {
		queue->tailNode->pNext = newNode;
		//queue->tailNode = newNode;
		//queue->curSize++;
	}
	queue->tailNode = newNode;
	queue->curSize++;
}
int front(LPQUEUE queue) {
	if (queue->frontNode != NULL) {
		return queue->frontNode->data;
	}
	else {
		printf("empty queue!");
		return 0;
	}
	
}
//出队
void pop(LPQUEUE queue) {
	//链表头删法
	if (queue == NULL || queue->curSize == 0) {
		printf("empty queue!");
	}
	else {
		struct Node* nextNode = queue->frontNode->pNext;
		free(queue->frontNode);
		queue->frontNode = nextNode;
		queue->curSize--;
	}
	
}

int main() {
	LPQUEUE queue = createQueue();
	for (int i = 0; i < 10; i++) {
		push(queue, i);
	}
	while (!empty(queue)) {
		printf("%d ", front(queue));
		pop(queue);
	}
	push(queue, 100);
	printf("%d ", front(queue));


	return 0;
}

优先队列

/*
	优先队列是按照优先权（自己设定的任何规则）出队
*/
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#define MAX 100
typedef struct Data{
	int priority;		//比较准则
	char name[20];		//数据本身

}DATA,*LPDATA,DARR[MAX];

//队列结构
typedef struct Queue {
	int curSize;
	DARR qMem;
}PRIO,*LPPRIO;
//创建队列
LPPRIO createPriorityQueue() {
	LPPRIO  priQueue = (LPPRIO)malloc(sizeof(Queue));
	assert(priQueue);
	priQueue->curSize = 0;
	memset(priQueue->qMem, 0, sizeof(DATA) * MAX);
	return priQueue;
}
int size(LPPRIO priQueue) {
	return priQueue->curSize;
}
int empty(LPPRIO priQueue) {
	return priQueue->curSize == 0;
}
//入队
void push(LPPRIO priQueue,DATA data) {
	if (priQueue->curSize == MAX) {
		printf("full queue!");
	}
	else {
		priQueue->qMem[priQueue->curSize++] = data;
	}

}
void pop(LPPRIO priQueue, DATA* data) {
	//按从小到大出队，贪心算法，每次取最小
	if (priQueue->curSize == 0) {
		printf("empty queue!");
	}
	else {
		DATA minData = priQueue->qMem[0];
		int minIndex = 0;
		for (int i = 1; i < priQueue->curSize; i++) {
			if (minData.priority > priQueue->qMem[i].priority) {
				minData = priQueue->qMem[i];
				minIndex = i;
			}
		}
		*data = minData;
		//伪删除
		for (int i = minIndex; i < priQueue->curSize; i++) {
			priQueue->qMem[i] = priQueue->qMem[i + 1];		
		}
		priQueue->curSize--;
	}
}



int main() {
	LPPRIO queue = createPriorityQueue();
	DATA arr[5] = {
		{5,"张三"},
		{13,"李四"},
		{2,"王二"},
		{6,"小李"},
		{9,"小张"}
	};
	for (int i = 0; i < 5; i++) {
		push(queue, arr[i]);
	}
	while (!empty(queue)) {
		DATA temp;
		pop(queue, &temp);
		printf("%d:%s\n", temp.priority, temp.name);
	}

	return 0;
}