Estructura de datos: implementación de cola secuencial y cola encadenada

Una cola es una lista lineal limitada a inserciones en un extremo y eliminaciones en el otro . La cola también se denomina tabla lineal Primero en entrar, primero en salir (primero en entrar, primero en salir), o FIFO para abreviar.

2. Líder del equipo

El final que permite la eliminación de elementos se llama cabecera de la cola . Como se muestra abajo:

3. El fin del equipo

El final que permite la inserción de elementos se llama cola de la cola . Como se muestra abajo:

2. Interfaz

1. Interfaz grabable

1) Cola de datos

La operación de inserción de la cola se llama poner en cola . Es el proceso de insertar elementos de datos desde el final de la cola , como se muestra en la figura, que representa el proceso de insertar dos datos (verde y azul):

2) Eliminación de la cola de datos

La operación de eliminación de la cola se llama quitar la cola . Es el proceso de eliminar el primer elemento del equipo, como se muestra en la figura, que representa el proceso de eliminar dos datos (rojo y naranja) en secuencia:

3) Limpiar la cola

La operación de borrado de la cola es el proceso de quitar la cola hasta que la cola esté vacía. Cuando el principio y el final de la cola coinciden, significa que el final de la cola está vacío, como se muestra en la figura:

2. Interfaz de solo lectura

1) Obtener datos del líder del equipo

Para una cola, solo se pueden obtener los datos principales y, por lo general, no se admiten otros datos.

2) Obtener el número de elementos de la cola.

El número de elementos de la cola generalmente se almacena en una variable adicional, que aumenta en uno al ingresar a la cola y disminuye en uno al salir de la cola . De esta manera, no es necesario recorrer toda la cola para obtener elementos de la cola. Obtenga el número de elementos de la cola con complejidad temporal O (1).

3) Juicio vacío de la cola

Cuando el número de elementos de la cola es cero, es una cola vacía y no se permiten operaciones de retirada de la cola para colas vacías .

3. Implementación de la tabla de secuencia de colas

1. Definición de estructura de datos

Para la tabla de secuencia, que se representa como una matriz en lenguaje C , antes de definir la cola , debemos considerar los siguientes puntos:
1) El método de almacenamiento de los datos de la cola y el tipo de datos de los datos de la cola;
2) El tamaño de la cola;
3) puntero de cabeza de equipo;
4) puntero de cola de equipo;

Podemos definir una estructura de cola y la implementación del lenguaje C es la siguiente:

#define MAXSIZE 10
typedef int datatype;

typedef struct seqqueue{
	datatype data[MAXSIZE];
	int front,rear;
}seq_queue,*seq_pqueue;

2. Inicialice la cola de creación.

El primer parámetro invisible se implementa en lenguaje C de la siguiente manera:

seq_pqueue init1_seqqueue(void)
{
	seq_pqueue q;
	q=(seq_pqueue)malloc(sizeof(seq_queue));
	if(q==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	q->front=q->rear=MAXSIZE-1;

	return q;
}

El segundo tipo de parámetros formales se implementa en lenguaje C de la siguiente manera:

void init_seqqueue(seq_pqueue *Q)
{
	*Q=(seq_pqueue)malloc(sizeof(seq_queue));
	if((*Q)==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	(*Q)->front=(*Q)->rear=MAXSIZE-1;
	
	return;
}

3. Determinar si la cola está llena.

La implementación del lenguaje C es la siguiente:

bool is_full_seqqueue(seq_pqueue q)
{
	if((q->rear+1)%MAXSIZE == q->front)
		return true;
	else
		return false;
}

4. Determinar si la cola está vacía.

La implementación del lenguaje C es la siguiente:

bool is_empty_seqqueue(seq_pqueue q)
{
	if(q->rear == q->front)
		return true;
	else
		return false;
}

5. Únete al equipo

La implementación del lenguaje C es la siguiente:

bool in_seqqueue(datatype data,seq_pqueue q)
{
	//判断队列是否满
	if(is_full_seqqueue(q)){
		printf("队列已满!\n");
		return false;
	}

	//入队
	q->rear=(q->rear+1)%MAXSIZE;
	q->data[q->rear]=data;
	return true;
}

6. Deja el equipo

La implementación del lenguaje C es la siguiente:

bool out_seqqueue(seq_pqueue q,datatype *D)
{
	//判断队列是否空
	if(is_empty_seqqueue(q)){
		printf("队列已空!\n");
		return false;
	}

	//出队
	q->front=(q->front+1)%MAXSIZE;
	*D=q->data[q->front];

	return true;
}

7. Cola de impresión

La implementación del lenguaje C es la siguiente:

void show_seqqueue(seq_pqueue q)
{
	int i;
	if(is_empty_seqqueue(q))
		return;
	//非空时，从对头打印到队尾
	for(i=(q->front+1)%MAXSIZE;i!=(q->rear+1)%MAXSIZE;i=(i+1)%MAXSIZE)
	{
		printf("%d\t",q->data[i]);
	}
	printf("\n");
}

8. Código fuente de implementación de la tabla de secuencia de colas

secuencia.h

#ifndef __SEQQUEUE_H__
#define __SEQQUEUE_H__

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

#define MAXSIZE 10
typedef int datatype;

typedef struct seqqueue{
	datatype data[MAXSIZE];
	int front,rear;
}seq_queue,*seq_pqueue;

extern seq_pqueue init1_seqqueue(void);
extern void init_seqqueue(seq_pqueue *Q);
extern bool is_full_seqqueue(seq_pqueue q);
extern bool is_empty_seqqueue(seq_pqueue q);
extern bool in_seqqueue(datatype data,seq_pqueue q);
extern bool out_seqqueue(seq_pqueue q,datatype *D);
extern void show_seqqueue(seq_pqueue q);

#endif

secuencia.c

#include "seqqueue.h"

seq_pqueue init1_seqqueue(void)
{
	seq_pqueue q;
	q=(seq_pqueue)malloc(sizeof(seq_queue));
	if(q==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	q->front=q->rear=MAXSIZE-1;

	return q;
}

void init_seqqueue(seq_pqueue *Q)
{
	*Q=(seq_pqueue)malloc(sizeof(seq_queue));
	if((*Q)==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	(*Q)->front=(*Q)->rear=MAXSIZE-1;
	
	return;
}

//判断队列是否满
bool is_full_seqqueue(seq_pqueue q)
{
	if((q->rear+1)%MAXSIZE == q->front)
		return true;
	else
		return false;
}

//入队
bool in_seqqueue(datatype data,seq_pqueue q)
{
	//判断队列是否满
	if(is_full_seqqueue(q)){
		printf("队列已满!\n");
		return false;
	}

	//入队
	q->rear=(q->rear+1)%MAXSIZE;
	q->data[q->rear]=data;
	return true;
}

//判断队列是否空
bool is_empty_seqqueue(seq_pqueue q)
{
	if(q->rear == q->front)
		return true;
	else
		return false;
}

//出队
bool out_seqqueue(seq_pqueue q,datatype *D)
{
	//判断队列是否空
	if(is_empty_seqqueue(q)){
		printf("队列已空!\n");
		return false;
	}

	//出队
	q->front=(q->front+1)%MAXSIZE;
	*D=q->data[q->front];

	return true;
}

void show_seqqueue(seq_pqueue q)
{
	int i;
	if(is_empty_seqqueue(q))
		return;
	//非空时，从对头打印到队尾
	for(i=(q->front+1)%MAXSIZE;i!=(q->rear+1)%MAXSIZE;i=(i+1)%MAXSIZE)
	{
		printf("%d\t",q->data[i]);
	}
	printf("\n");
}

prueba.c

#include "seqqueue.h"
/* 用循环队列实现如下功能：
 * 用户从键盘输入整数，程序将其入队;
 * 用户从键盘输入字母，程序将队头元素出队;
 * 并在每一次出队和入队之后打印队列元素。
 */
int main(int argc, const char *argv[])
{
	seq_pqueue q;
	datatype data,t,ret;
	
	init_seqqueue(&q);

	while(1)
	{
		printf("请输入一个整数或字符:");
		ret=scanf("%d",&data);
		
		//输入整数时，入队
		if(ret == 1)
		{
			if(in_seqqueue(data,q))
				show_seqqueue(q);
		}
		else
		{
			//输入为字符时
			if(out_seqqueue(q,&t))
			{
				printf("out:%d\n",t);
				show_seqqueue(q);
			}
			//清空输入缓冲区
			while(getchar()!='\n');
		}
	}
	return 0;
}

Archivo Make

CC = gcc
CFLAGS = -o0 -g -Wall

SRC=seqqueue.c test.c
OBJS=test

$(OBJS):$(SRC)
	$(CC) $(CFLAGS) -o $@ $^

.PHONY:clean
clean:
	rm -rf $(OBJS) *.o

"-o0" significa que el nivel de optimización es 0, es decir, la optimización está desactivada. Esto dará como resultado un archivo ejecutable más grande, pero se puede depurar fácilmente.
"-g" significa generar información de depuración para que pueda ver los valores de las variables, las pilas de llamadas de funciones y otra información al depurar el programa.
"-Wall" significa habilitar todas las advertencias y el compilador mostrará todos los mensajes de advertencia posibles para ayudar a los desarrolladores a encontrar problemas potenciales.

Prueba de resultado de compilación:

4. Implementación de lista vinculada en cola

1. Definición de estructura de datos

Para listas enlazadas, antes de definir la cola , debemos considerar los siguientes puntos:
1) El método de almacenamiento de los datos de la cola y el tipo de datos de los datos de la cola;
2) El tamaño de la cola;
3) El puntero principal de la cola;
4) El puntero de cola de la cola;

Podemos definir una estructura de cola y la implementación del lenguaje C es la siguiente:

typedef int datatype;

typedef struct linkqueuenode{ 
	datatype data;                    /* 数据域 */
	struct linkqueuenode *next;       /* 指针域 */
}linkqueue_node,*linkqueue_pnode;

typedef struct linkqueue{
	linkqueue_pnode front,rear;       /* 链队列指针 */
}link_queue,*link_pqueue;

2. Inicialice la cola de creación.

La implementación del lenguaje C es la siguiente:

void init_linkqueue(link_pqueue *Q)
{
	//申请front和rear的空间
	*Q=(link_pqueue)malloc(sizeof(link_queue));
	if((*Q)==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	//申请头结点空间
	(*Q)->front=(linkqueue_pnode)malloc(sizeof(linkqueue_node));
	if((*Q)->front==NULL)
	{
		perror("malloc");
		exit(-1) ;
	}

	(*Q)->front->next=NULL;
	(*Q)->rear=(*Q)->front;

	return;
}

3. Determinar si la cola está vacía.

La implementación del lenguaje C es la siguiente:

bool is_empty_linkqueue(link_pqueue q)
{
	if(q->rear == q->front)
		return true;
	else
		return false;
}

4. Únete al equipo

La implementación del lenguaje C es la siguiente:

bool in_linkqueue(datatype data,link_pqueue q)
{
	linkqueue_pnode  new;

	//申请数据结点空间
	new=(linkqueue_pnode)malloc(sizeof(linkqueue_node));
	if(new==NULL)
	{
		puts("入队失败！");
		return false;
	}
	//将数据存储在申请的空间
	new->data=data;
	
	//将new指向的结点插入到链式队列中
	new->next=q->rear->next;
	q->rear->next=new;
	
	//让rear指针指向新的队尾结点
	q->rear=q->rear->next;

	return true;
}

5. Deja el equipo

La implementación del lenguaje C es la siguiente:

bool out_linkqueue(link_pqueue q,datatype *D)
{
	linkqueue_pnode t;
	//判断队列是否空
	if(is_empty_linkqueue(q)){
		printf("队列已空!\n");
		return false;
	}

	//出队
	t=q->front;
	q->front =q->front->next;
	*D=q->front->data;
	free(t);

	return true;
}

6. Cola de impresión

La implementación del lenguaje C es la siguiente:

void show_linkqueue(link_pqueue q)
{
	linkqueue_pnode p;
	if(is_empty_linkqueue(q))
		return;
	//非空时，从对头打印到队尾
	for(p=q->front->next;p!=NULL;p=p->next)
	{
		printf("%d\t",p->data);
	}
	printf("\n");
}

7. Código fuente de implementación de lista vinculada en cola

cola de enlace.h

#ifndef __LINKQUEUE_H__
#define __LINKQUEUE_H__

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

typedef int datatype;

typedef struct linkqueuenode{
	datatype data;
	struct linkqueuenode *next;
}linkqueue_node,*linkqueue_pnode;

typedef struct linkqueue{
	linkqueue_pnode front,rear;
}link_queue,*link_pqueue;

extern void init_linkqueue(link_pqueue *Q);
extern bool is_empty_linkqueue(link_pqueue q);
extern bool in_linkqueue(datatype data,link_pqueue q);
extern bool out_linkqueue(link_pqueue q,datatype *D);
extern void show_linkqueue(link_pqueue q);

#endif

cola de enlace.c

#include "linkqueue.h"

void init_linkqueue(link_pqueue *Q)
{
	//申请front和rear的空间
	*Q=(link_pqueue)malloc(sizeof(link_queue));
	if((*Q)==NULL)
	{
		perror("malloc");
		exit(-1);
	}
	//申请头结点空间
	(*Q)->front=(linkqueue_pnode)malloc(sizeof(linkqueue_node));
	if((*Q)->front==NULL)
	{
		perror("malloc");
		exit(-1) ;
	}

	(*Q)->front->next=NULL;
	(*Q)->rear=(*Q)->front;

	return;
}

//入队
bool in_linkqueue(datatype data,link_pqueue q)
{
	linkqueue_pnode  new;

	//申请数据结点空间
	new=(linkqueue_pnode)malloc(sizeof(linkqueue_node));
	if(new==NULL)
	{
		puts("入队失败！");
		return false;
	}
	//将数据存储在申请的空间
	new->data=data;
	
	//将new指向的结点插入到链式队列中
	new->next=q->rear->next;
	q->rear->next=new;
	
	//让rear指针指向新的队尾结点
	q->rear=q->rear->next;

	return true;
}

bool is_empty_linkqueue(link_pqueue q)
{
	if(q->rear == q->front)
		return true;
	else
		return false;
}

//出队
bool out_linkqueue(link_pqueue q,datatype *D)
{
	linkqueue_pnode t;
	//判断队列是否空
	if(is_empty_linkqueue(q)){
		printf("队列已空!\n");
		return false;
	}

	//出队
	t=q->front;
	q->front =q->front->next;
	*D=q->front->data;
	free(t);

	return true;
}

void show_linkqueue(link_pqueue q)
{
	linkqueue_pnode p;
	if(is_empty_linkqueue(q))
		return;
	//非空时，从对头打印到队尾
	for(p=q->front->next;p!=NULL;p=p->next)
	{
		printf("%d\t",p->data);
	}
	printf("\n");
}

prueba.c

#include "linkqueue.h"
/* 用链式队列实现如下功能：
 * 用户从键盘输入整数，程序将其入对;
 * 用户从键盘输入字母，程序将队头元素出队;
 * 并在每一次出队和入队之后打印队列元素。
 */
int main(int argc, const char *argv[])
{
	link_pqueue q;
	datatype data,t,ret;
	
	init_linkqueue(&q);

	while(1)
	{
		printf("请输入一个整数或字符:");
		ret=scanf("%d",&data);
		
		//输入整数时，入对
		if(ret == 1)
		{
			if(in_linkqueue(data,q))
				show_linkqueue(q);
		}
		else
		{
			//输入为字符时
			if(out_linkqueue(q,&t))
			{
				printf("out:%d\n",t);
				show_linkqueue(q);
			}
			//清空输入缓冲区
			while(getchar()!='\n');
		}
	}
	return 0;
}

Archivo Make

CC = gcc
CFLAGS = -o0 -g -Wall

SRC=linkqueue.c test.c
OBJS=test

$(OBJS):$(SRC)
	$(CC) $(CFLAGS) -o $@ $^

.PHONY:clean
clean:
	rm -rf $(OBJS) *.o

"-o0" significa que el nivel de optimización es 0, es decir, la optimización está desactivada. Esto dará como resultado un archivo ejecutable más grande, pero se puede depurar fácilmente.
"-g" significa generar información de depuración para que pueda ver los valores de las variables, las pilas de llamadas de funciones y otra información al depurar el programa.
"-Wall" significa habilitar todas las advertencias y el compilador mostrará todos los mensajes de advertencia posibles para ayudar a los desarrolladores a encontrar problemas potenciales.

Prueba de resultado de compilación: