Cola de estructura de datos (lenguaje C)

Others 2021-03-23 09:52:37 views: null

Cola de implementación del lenguaje C

Descarga de código de GitHub

https://github.com/Kyrie-leon/Data_Structures/tree/main/stack_queue
Después de dominar el proceso de implementación de la pila ( estructura de datos-pila (lenguaje C) ), la implementación de la cola será muy simple

1. El concepto y la estructura de las colas

Cola : una tabla lineal especial que solo permite insertar datos en un extremo y eliminar datos en el otro extremo. La cola tieneFIFO primero en entrar, primero en salir(Primero en
entrar, primero en salir) en la cola : se llama al final de la operación de inserciónFin
de la cola == Fuera de la cola : Se llama al final que realiza la operación de eliminaciónJefe de equipo ==

Inserte la descripción de la imagen aquí

En segundo lugar, la realización de la cola.

Las colas también se pueden implementar en la estructura de matrices y listas enlazadas. Es mejor usar la estructura de listas enlazadas , porque si se usa la estructura de una matriz , la eficiencia de la salida de datos de la cola en la cabecera de la matriz aumentará. ser relativamente bajo.

Inserte la descripción de la imagen aquí

2.1 Almacenamiento de la estructura de la cadena de la cola

typedef int QDataType;

//队列的链表
typedef struct QListNode
{
    
    
	struct QListNode* _next;
	QDataType _data;
}QNode;

//队列的结构
typedef struct Queue
{
    
    
	QNode *_front;	//队头
	QNode *_rear;	//队尾
}Queue;

2.2 Inicializar la cola

// 初始化队列 
void QueueInit(Queue* pq)
{
    
    
	assert(pq);
	pq->_front = pq->_rear = NULL;	//队头队尾置空即可

}

2.3 Cola al final del equipo

// 队尾入队列 
void QueuePush(Queue* pq, QDataType data)
{
    
    
	assert(pq);
	QNode * newNode = (QNode *)malloc(sizeof(QNode));	//向内存申请一个结点
	//判断是否申请成功
	if (NULL == newNode)
	{
    
    
		printf("申请失败!\n");
		exit(-1);
	}
	//将新节点入到队尾
	newNode->_data = data;	//数据data赋值给新节点	
	newNode->_next = NULL;	//新节点会作为队尾节点，因此对新节点_next置空
	
	if (pq->_front)
	{
    
    
		pq->_rear->_next = newNode;		//队列不为空，队尾结点先链接新结点
		pq->_rear = newNode;	//再将队尾指向新节点	
	}
	else
	{
    
    
		pq->_front = pq->_rear = newNode;	//如果队列为空，则队头队尾都指向新节点
	}
}

2.4 Sal de la cola

// 队头出队列 
void QueuePop(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_front);	//出队列判断队列是否为空
	QNode* next = pq->_front->_next;	//next保存新队头结点
	free(pq->_front);
	pq->_front = next;
	//出队列后需要判断队列是否为空
	if (NULL == pq->_front)
	{
    
    
		pq->_rear = NULL;	//如果为空，则队尾也为空
	}
}

2.5 Obtener el elemento principal de la cola

// 获取队列头部元素 
QDataType QueueFront(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_front);
	return pq->_front->_data;
}

2.6 Obtener el elemento de cola de la cola

// 获取队列队尾元素 
QDataType QueueBack(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_rear);
	return pq->_rear->_data;
}

2.7 Obtener el número de elementos válidos en la cola

En)

// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
    
    
	assert(pq);
	int size = 0;
	QNode* cur = pq->_front;
	//遍历一遍链表
	while (cur)
	{
    
    
		size++;
		cur = cur->_next;
	}
	return size;
}

2.8 Verifique si la cola está vacía, si está vacía, devuelva un resultado distinto de cero, si no está vacía, devuelva 0

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq)
{
    
    
	assert(pq);
	return pq->_front == NULL ? 1 : 0;
}

2.9 Destruye la cola

// 销毁队列 
void QueueDestroy(Queue* pq)
{
    
    
	assert(pq);
	//从头节点开始遍历每一个节点并free
	QNode* cur = pq->_front;
	while (cur)
	{
    
    
		QNode* next = cur->_next;	//cur指向下一个节点
		free(cur);
		cur = next;
	}
	pq->_front = pq->_rear = NULL;
}

Tres, la prueba de interfaz de la cola.

#include "Queue.h"

void TestQueue()
{
    
    
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!(QueueEmpty(&q)))
	{
    
    
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestroy(&q);
}

int main()
{
    
    
	//TestStack();
	TestQueue();
	system("pause");
	return 0;
}

Inserte la descripción de la imagen aquí

Cuarto, la lista de códigos

4.1 Queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<windows.h>

typedef int QDataType;

//队列的链表
typedef struct QListNode
{
    
    
	struct QListNode* _next;
	QDataType _data;
}QNode;

//队列的结构
typedef struct Queue
{
    
    
	QNode *_front;	//队头
	QNode *_rear;	//队尾
}Queue;

// 初始化队列 
void QueueInit(Queue* pq);
// 队尾入队列 
void QueuePush(Queue* pq, QDataType data);
// 队头出队列 
void QueuePop(Queue* pq);
// 获取队列头部元素 
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素 
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数 
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq);
// 销毁队列 
void QueueDestroy(Queue* pq);

4.2 Cola.c

#include "Queue.h"

// 初始化队列 
void QueueInit(Queue* pq)
{
    
    
	assert(pq);
	pq->_front = pq->_rear = NULL;	//队头队尾置空即可

}
// 队尾入队列 
void QueuePush(Queue* pq, QDataType data)
{
    
    
	assert(pq);
	QNode * newNode = (QNode *)malloc(sizeof(QNode));	//向内存申请一个结点
	//判断是否申请成功
	if (NULL == newNode)
	{
    
    
		printf("申请失败!\n");
		exit(-1);
	}
	//将新节点入到队尾
	newNode->_data = data;	//数据data赋值给新节点	
	newNode->_next = NULL;	//新节点会作为队尾节点，因此对新节点_next置空
	
	if (pq->_front)
	{
    
    
		pq->_rear->_next = newNode;		//队列不为空，队尾结点先链接新结点
		pq->_rear = newNode;	//再将队尾指向新节点	
	}
	else
	{
    
    
		pq->_front = pq->_rear = newNode;	//如果队列为空，则队头队尾都指向新节点
	}
}

// 队头出队列 
void QueuePop(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_front);	//出队列判断队列是否为空
	QNode* next = pq->_front->_next;	//next保存新队头结点
	free(pq->_front);
	pq->_front = next;
	//出队列后需要判断队列是否为空
	if (NULL == pq->_front)
	{
    
    
		pq->_rear = NULL;	//如果为空，则队尾也为空
	}
}
// 获取队列头部元素 
QDataType QueueFront(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_front);
	return pq->_front->_data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* pq)
{
    
    
	assert(pq);
	assert(pq->_rear);
	return pq->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
    
    
	assert(pq);
	int size = 0;
	QNode* cur = pq->_front;
	//遍历一遍链表
	while (cur)
	{
    
    
		size++;
		cur = cur->_next;
	}
	return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq)
{
    
    
	assert(pq);
	return pq->_front == NULL ? 1 : 0;
}
// 销毁队列 
void QueueDestroy(Queue* pq)
{
    
    
	assert(pq);
	//从头节点开始遍历每一个节点并free
	QNode* cur = pq->_front;
	while (cur)
	{
    
    
		QNode* next = cur->_next;	//cur指向下一个节点
		free(cur);
		cur = next;
	}
	pq->_front = pq->_rear = NULL;
}

4.3 prueba.c

#include "stack.h"
#include "Queue.h"

void TestStack()
{
    
    
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	while (!StackEmpty(&ps))
	{
    
    

		printf("%d, %d\n", StackTop(&ps),StackSize(&ps));
		StackPop(&ps);
	}

	
}

void TestQueue()
{
    
    
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!(QueueEmpty(&q)))
	{
    
    
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestroy(&q);
}

int main()
{
    
    
	//TestStack();
	TestQueue();
	system("pause");
	return 0;
}

Supongo que te gusta

Origin blog.csdn.net/qq_40076022/article/details/112306861
Recomendado
Clasificación
Diario
Más
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)
2024-04-28(9)
2024-04-27(28)
2024-04-26(22)
2024-04-25(34)

Code World

© 2018 codetd.com