C语言数据结构队列的概念及结构、队列的实现、队列结构的创建、初始化队列、销毁队列、入队列、出队列、获取队列元素个数、判断队列是否为空、获取队列头元素、获取队列尾元素、测试等的介绍

前言

C语言数据结构队列的概念及结构、队列的实现、队列结构的创建、初始化队列、销毁队列、入队列、出队列、获取队列元素个数、判断队列是否为空、获取队列头元素、获取队列尾元素、测试等的介绍

---

队列的概念及结构

• 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
• 入队列：进行插入操作的一端称为队尾
• 出队列：进行删除操作的一端称为队头

队列的实现

• 队列可以使用数组或者链表的结构实现。
• 但是使用链表的结构实现更优一些。
• 因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

一、 队列结构创建

队列结构的创建

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;



typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
} Queue;

---

二、 初始化队列

初始化队列

// 初始化队列
void QInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}

---

三、 销毁队列

销毁队列定义

// 销毁队列
void QDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

四、 入队列

入队列定义

// 入队列
void QPush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QPush()::malloc()");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;

	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
	pq->size++;
}

五、 出队列

出队列定义

// 出队列
void QPop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* cur = pq->head;
		pq->head = cur->next;

		free(cur);
		cur = NULL;
	}
	pq->size--;
	
}

六、 获取队列元素个数

获取队列元素个数定义

// 获取队列元素个数
int QSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

七、 判断队列是否为空

判断队列是否为空定义

// 判断队列是否为空
bool QEmpty(Queue* ps)
{
	assert(ps);

	return (ps->head == NULL && ps->tail == NULL);
}

八、 获取队列头元素

初始化结构定义

// 找到队列的头元素
QDataType QFront(Queue* ps)
{
	assert(ps);
	assert(!QEmpty(ps));

	return (ps->head->data);
}

九、 获取队列尾元素

初始化结构定义

// 找到队列的尾元素
QDataType QBack(Queue* ps)
{
	assert(ps);
	assert(!QEmpty(ps));

	return (ps->tail->data);
}

十、测试

测试

#include "Queue.h"

int main()
{

	Queue q = { 0 };

	// 初始化队列
	QInit(&q);

	// 入队列
	QPush(&q, 1);
	QPush(&q, 2);
	QPush(&q, 3);
	QPush(&q, 4);
	QPush(&q, 5);

	// 队列尾元素
	printf("%d\n", QBack(&q)); // 5

	// 获取队列中元素个数
	printf("%d\n", QSize(&q)); // 5


	while (!QEmpty(&q))
	{

		printf("%d ", QFront(&q)); // 1 2 3 4 5
		QPop(&q);
	}
	printf("\n");


	// 销毁队列
	QDestroy(&q);

	return 0;
}

效果如下：

leetcode队列实现栈

---

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;



typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
} Queue;


// 初始化队列
void QInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}


// 销毁队列
void QDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}


// 入队列
void QPush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("QPush()::malloc()");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;

	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
	pq->size++;
}

// 出队列
void QPop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* cur = pq->head;
		pq->head = cur->next;

		free(cur);
		cur = NULL;
	}
	pq->size--;
	
}



// 获取队列元素个数
int QSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}


// 判断队列是否为空
bool QEmpty(Queue* pq)
{
	assert(pq);

	return (pq->head == NULL && pq->tail == NULL);
}


// 找到队列的头元素
QDataType QFront(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->head->data);
}


// 找到队列的尾元素
QDataType QBack(Queue* pq)
{
	assert(pq);
	assert(!QEmpty(pq));

	return (pq->tail->data);
}


typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    if(pst == NULL)
    {
        perror("myStackCreate malloc");
        return NULL;
    }

    QInit(&pst->q1);
    QInit(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QEmpty(&obj->q1))
    {
        QPush(&obj->q1, x);
    }
    else
    {
        QPush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;

    if(!QEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    while(QSize(nonempty) > 1)
    {
        QPush(empty, QFront(nonempty));
        QPop(nonempty);
    }

    int top = QFront(nonempty);
    QPop(nonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QEmpty(&obj->q1))
    {
        return QBack(&obj->q1);
    }
    else
    {
        return QBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return (QEmpty(&obj->q1) && QEmpty(&obj->q2));
}

void myStackFree(MyStack* obj) {
    QDestroy(&obj->q1);
    QDestroy(&obj->q2);

    obj = NULL;
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

---

总结

C语言数据结构队列的概念及结构、队列的实现、队列结构的创建、初始化队列、销毁队列、入队列、出队列、获取队列元素个数、判断队列是否为空、获取队列头元素、获取队列尾元素、测试等的介绍