Datenstruktur ----- Warteschlange

Inhaltsverzeichnis

Vorwort

Warteschlange

Definition 

Warteschlangendefinition und Betriebsmethoden

 Definition des Warteschlangenknotens

 Operationsmethode

 Sequenztabellen-Implementierungswarteschlange (C/C++-Code)

Implementierungswarteschlange für verknüpfte Listen (C/C++-Code)

Die Python-Sprache implementiert eine Warteschlange

---

Vorwort

        Das Anstehen ist ein wesentlicher Bestandteil unseres täglichen Lebens. Das Anstehen beim Gang zur Kantine, um Essen zu holen, das Anstehen beim Einsteigen in den Bus usw. Beim Anstehen gilt das Prinzip „Wer zuerst kommt, mahlt zuerst“ und wer vorne ist, bekommt sein Essen zuerst . . Ebenso gibt es unter den Datenstrukturen einen Datenstrukturtyp namens Warteschlange, dessen Eigenschaften genau denen von Warteschlangen entsprechen. Schauen wir uns das gemeinsam an!

Warteschlange

Definition 

        Die Warteschlange ist eine spezielle lineare Tabelle . Das Besondere ist, dass sie nur Löschvorgänge am vorderen Ende (vorne) der Tabelle und Einfügevorgänge am hinteren Ende (hinten) der Tabelle zulässt. Wie der Stapel ist die Warteschlange eine Operation, die der eingeschränkten linearen Tabelle unterliegt. Das Ende, das den Einfügevorgang ausführt, wird als Ende der Warteschlange bezeichnet, und das Ende, das den Löschvorgang ausführt, wird als Kopf der Warteschlange bezeichnet. Wenn die Warteschlange keine Elemente enthält, spricht man von einer leeren Warteschlange.

        Die Datenelemente der Warteschlange werden auch Warteschlangenelemente genannt. Das Einfügen eines Warteschlangenelements in die Warteschlange wird als Enqueuing bezeichnet, und das Löschen eines Warteschlangenelements aus der Warteschlange wird als Dequeuing bezeichnet. Da die Warteschlange nur das Einfügen an einem Ende und das Löschen am anderen Ende zulässt, kann nur das Element, das am frühesten in die Warteschlange eintritt, zuerst aus der Warteschlange gelöscht werden. Daher wird die Warteschlange auch als „First-in-first-out“ (FIFO – zuerst) bezeichnet in first out) lineare Liste .

 

Warteschlangen können durch Sequenzlisten und verknüpfte Listen implementiert werden. Schauen wir uns das gemeinsam an!  

Warteschlangendefinition und Betriebsmethoden

 Definition des Warteschlangenknotens

Sequenztabelle:

//队列定义
typedef struct queue {
	ElemType data[Maxsize];
	int front;//指向队头
	int rear;//指向队尾
}Queue;

Kette:

//定义队列
typedef struct queue {
	int count;	//计数
	Node* front;//指向队头指针
	Node* rear;//指向队尾指针
}Queue;

 Operationsmethode

void Queue_init(Queue* queue);//初始化

bool isEmpty(Queue* queue);//判空

bool isFull(Queue* queue);//判满

void enQueue(Queue* queue, ElemType data);//入队

Node* deQueue(Queue* queue);//出队

int get_length(Queue* queue);//获取长度

void travel_Queue(Queue* queue);//遍历（队头到队尾）

void clear_Queue(Queue* queue);//清空销毁

 Sequenztabellen-Implementierungswarteschlange (C/C++-Code)

#include <stdio.h>
#include<string.h>
#define Maxsize 20 //最大容量
//顺序表队列

//节点数据
typedef struct data {
	int num;
	char name[10];
}ElemType;
//队列定义
typedef struct queue {
	ElemType data[Maxsize];
	int front;//指向队头
	int rear;//指向队尾
}Queue;

//初始化
void queue_init(Queue* queue) {
	queue->front = 0;
	queue->rear = 0;
}

//判断是否满队列
bool isFull(Queue* queue) {
	if (queue->rear == Maxsize) {
		printf("The queue is full\n");
		return true;
	}
	return false;
}

//判断是否空队列
bool isEmpty(Queue* queue) {
	if (queue->rear == 0) {
		printf("The queue is etmpy\n");
		return true;
	}
	return false;
}

//入队操作
void enQueue(Queue* queue, ElemType data) {
	if (!isFull(queue)) {
        //赋值
		queue->data[queue->rear].num = data.num;
		strcpy(queue->data[queue->rear].name, data.name);
		queue->rear++;	//队尾+1，往后移动一位
	}
	else
		printf("error\n");
}

//出队操作
ElemType deQueue(Queue* queue) {
	ElemType de_data = { 0 };
	if (!isFull(queue)) {
		de_data = queue->data[queue->front];
		queue->front++;	//队头+1往后移动一位
		return de_data;
	}
	else
		printf("error\n");
}

//遍历队列（从队头开始到队尾）
void travel_Queue(Queue* queue) {
	for (int i = queue->front; i < queue->rear; i++) {
		printf("%d %s\n", queue->data[i].num, queue->data[i].name);
	}
	printf("printf over!\n");
}

//获取队列长度
int get_Queuelength(Queue* queue) {
	return queue->rear-queue->front;
}

//清空队列
void clear_Queue(Queue* queue) {
	queue_init(queue);//直接恢复出厂设置
}

int main(void)
{
	Queue queue;
	queue_init(&queue);
	ElemType data[4] = { {15,"fuck"},{16,"wdf"},{17,"wtmc"},{18,"cnmb"} };
	for (int i = 0; i < 4;i++) {
		enQueue(&queue, data[i]);
	}
	deQueue(&queue);
	travel_Queue(&queue);
}

//16 wdf
//17 wtmc
//18 cnmb
//printf over!

Implementierungswarteschlange für verknüpfte Listen (C/C++-Code)

#include<stdio.h>
#include<string.h>
#include <stdbool.h>
#include<stdlib.h>
#include<assert.h>
#define Maxsize 20

typedef struct datatype {
	int num;
	char name[10];
}ElemType;
//定义节点
typedef struct node {
	ElemType data;
	struct node* next;
}Node;
//定义队列
typedef struct queue {
	int count;	//计数
	Node* front;//指向队头指针
	Node* rear;//指向队尾指针
}Queue;

void Queue_init(Queue* queue);//初始化
bool isEmpty(Queue* queue);//判空
bool isFull(Queue* queue);//判满
void enQueue(Queue* queue, ElemType data);//入队
Node* deQueue(Queue* queue);//出队
int get_length(Queue* queue);//获取长度
void travel_Queue(Queue* queue);//遍历
void clear_Queue(Queue* queue);//清空销毁

int main()
{
	Queue myqueue;
	Queue_init(&myqueue);
	ElemType data[4] = { {15,"a"},{16,"wb"},{17,"htt"},{18,"jk"} };
	for (int i = 0; i < 4; i++) {
		enQueue(&myqueue, data[i]);
	}
	deQueue(&myqueue);
	travel_Queue(&myqueue);
}
//16 wb
//17 htt
//18 jk
//Printf over


//初始化
void Queue_init(Queue* queue) {
	assert(queue);
	queue->front = NULL;
	queue->rear = NULL;
	queue->count=0;
}

//创建节点
Node* create_node(ElemType data) {
	Node* new_node = (Node*)malloc(sizeof(Node));
	if (new_node) {
		new_node->data = data;
		new_node->next = NULL;
		return new_node;
	}
	else
	{
		printf("ERRPR\n");
	}
}

//判断是否空队列
bool isEmpty(Queue* queue) {
	assert(queue);
	if (queue->count == 0)
	{
		printf("The queue is etmpy\n");
		return true;
	}
	return false;
}

//判断是否满队列
bool isFull(Queue* queue) {
	assert(queue);
	if (queue->count == Maxsize) {
		printf("The queue is full\n");
		return true;
	}
	return false;
}

//入队
void enQueue(Queue* queue, ElemType data) {
	assert(queue);
	if (!isFull(queue)) {
		Node* new_node = create_node(data);
        //如果队尾指向空的时候，也就是队列为空时
		if (queue->rear == NULL) {
			queue->front = new_node;
			queue->rear = new_node;
			queue->count++;
		}
        //当队列不为空的时候
		else
		{
			queue->rear->next = new_node;
			queue->rear = new_node;
			queue->count++;
		}
	}
	else
	{
		printf("error\n");
	}
}

//出队
Node* deQueue(Queue* queue) {
	assert(queue);
	if (!isEmpty(queue)) {
		Node* deNode = queue->front;
		queue->front = deNode->next;
		queue->count--;
		return deNode;
	}
	printf("error\n");
	return NULL;
}

//获取队列长度
int get_length(Queue* queue) {
	assert(queue);
	return queue->count;
}

//遍历队列
void travel_Queue(Queue* queue) {
	assert(queue);
	Node* cur = queue->front;
	while (cur) {
		printf("%d %s\n", cur->data.num, cur->data.name);
		cur = cur->next;
	}
	printf("Printf over\n");
}

//清空队列
void clear_Queue(Queue* queue) {
	assert(queue);
	Node* cur = queue->front;
	while (cur) {
        //要把每一个节点的空间都释放，避免内存泄漏
		Node* p = cur->next;    //获取到当前节点的下一个节点
		free(cur);
		cur = p;
	}
	printf("Clear successfully!\n");
}

Die Python-Sprache implementiert eine Warteschlange

Link: Python-Datenstruktur ----- Queue_python queue_Hui Letards Blog-CSDN-Blog

 Das ist alles für heute, wir sehen uns in der nächsten Ausgabe! ! !

Teilen Sie ein Hintergrundbild: