数据结构--第五天-CSDN博客

本文链接：https://blog.csdn.net/xujiashuo1/article/details/140797444

--队列

-队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特点

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

-入队

1.队列为空时，新建节点，并要用入队列的数据初始化，此时front和tail都指向新插入的节点，同时将size+1

2.队列不为空时，新建节点，并要用入队列的数据初始化节点，此时tail->next指向新插入的节点，更新tail指向新插入的节点

-出队

（按照“先进先出”的原则）

步骤1.检查队列是否为空

2.当队列中只有一个数据时，只需要将该数据所在节点释放，并将front和tail置空即可

当队列中有俩个及以上的数据时，保存头节点下一个节点的地址，释放头节点，更新front，使front指向新的队头元素

-队列示例代码

main.c

#include "quence.h"
#include "seq_list.h"

void menu();
int main(){
	int select;
	seqlist_t* sequence=NULL;
	do{
		menu();
		printf("请选择：");
		scanf("%d",&select);
		switch(select){
			case 1:
				if(sequence == NULL){
					sequence_init(&sequence);
				}
				dequence(sequence);
				break;
			case 2:
				if(sequence==NULL){
					sequence_init(&sequence);
				}
				enquence(sequence);
				break;
			case 3:
				if(sequence_is_empty(sequence)){
					printf("quence is empty\n");
				}else{
					printf("quence is not empty\n");
				}
				break;
			case 4:
				if(!sequence_is_empty(sequence)){
					display_sequence_head(sequence);
				}
				break; 
			case 5:
				get_sequence_size(sequence);
				break;
			case 6:
				clear_sequence(&sequence);
				exit(EXIT_FAILURE);
				break;
			efalut:
				printf("选择错误，重新选择\n");
		}
		
	}while(1);
	return 0;
}

void menu(){
	printf("--------------------stack------------------\n");
	printf("1、出队 pop\n");
	printf("2、入队 push\n");
	printf("3、判断队列是否为空\n");
	printf("4、查看队首元素\n");
	printf("5、队列中元素的个数\n");
	printf("6、退出\n");
	printf("---------------------END-------------------\n");
}

quence.c

#include "quence.h"

void sequence_init(seqlist_t** sequence){
	seqlist_t* p_sequence = (seqlist_t*)malloc(sizeof(seqlist_t));
	if(p_sequence==NULL){
		printf("malloc failure.\n");
		return;
	}
	p_sequence->size = 0;
	*sequence = p_sequence;
}

void enquence(seqlist_t* sequence){
        datatype_t* stu = (datatype_t*)malloc(sizeof(datatype_t));
        if(stu==NULL){
                printf("malloc failure:%s\n",strerror(errno));
                printf("入队失败\n");
                return;
        }
        memset(stu,0,sizeof(datatype_t));
        while(getchar()!='\n');
        printf("请输入姓名:");
        fgets(stu->name,sizeof(stu->name)-1,stdin);
        stu->name[strlen(stu->name)-1]='\0';
        printf("请输入id:");
        fgets(stu->id,sizeof(stu->id)-1,stdin);
        stu->id[strlen(stu->id)-1]='\0';
	printf("请输入年龄:");
	scanf("%hhd",&(stu->age));
        bool res = seqlist_insert_data(sequence,stu);
        if(res){
                printf("入队成功\n");
        }else{
                printf("入队失败\n");
        }
}

bool sequence_is_empty(seqlist_t* sequence){
        return seqlist_is_empty(sequence);
}

void dequence(seqlist_t* sequence){

        datatype_t* res = seqlist_remove_first_data(sequence);
        if(res==NULL){
                printf("NO DATA\n");
                return;
        }
        printf("姓名：%s,学号：%s,年龄：%d\n",res->name,res->id,res->age);
        free(res);
        res=NULL;
}

void clear_sequence(seqlist_t** sequence){
	seqlist_clean(*sequence);
	free(*sequence);
	*sequence=NULL;
}

void display_sequence_head(seqlist_t* sequence){
        datatype_t* result=seqlist_get_first_data(sequence);
        if(result==NULL){
                printf("sequence is empty.\n");
                return;
        }
        printf("sequence top:\n");
        printf("姓名：%s,学号：%s,年龄：%d\n",result->name,result->id,result->age);
}

void get_sequence_size(seqlist_t* sequence){
	if(sequence_is_empty(sequence)){
		printf("size=0\n");
	}else {
		printf("size=%d\n",sequence->size);
	}
}

qunence.h


#ifndef __HEAD_STACK_H__
#define __HEAD_STACK_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "seq_list.h"

extern void sequence_init(seqlist_t**);
extern void enquence(seqlist_t*);
extern void display_sequence_head(seqlist_t*);
extern bool sequence_is_empty(seqlist_t*);
extern void dequence(seqlist_t*);
extern void clear_sequence(seqlist_t**);
extern void get_sequence_size(seqlist_t*);
#endif

seq_list.c

#include "seq_list.h"

//创造新的顺序表
seqlist_t* create_empty_seqlist(){
	//使用malloc创造空间
	seqlist_t* p=(seqlist_t*)malloc(sizeof(seqlist_t));
	if(p==NULL){
		printf("创建失败\n");
		exit(EXIT_FAILURE);
	}
	memset(p,0,sizeof(seqlist_t));
	p->front=0;
	p->tail=0;
	p->size=0;
	return p;
}
//判断顺序表是否满了
bool seqlist_is_full(seqlist_t* p){
	return p->front==(p->tail+1)%MAX;
}
//判断顺序表是否为空
bool seqlist_is_empty(seqlist_t* p){
	return p==NULL||p->front==p->tail;
}
//添加数据
bool seqlist_insert_data(seqlist_t* p,datatype_t* data){
//先判断是否为满了
	if(seqlist_is_full(p)){
		printf("顺序表已满\n");
		return false;
	}
	p->buffer[p->tail]=data;
	p->tail=(p->tail+1)%MAX;
	p->size++;
	return true;
}
//显示数组的首元素
datatype_t* seqlist_get_first_data(seqlist_t* p){
	if(seqlist_is_empty(p)){
		printf("顺序表为空\n");
		return NULL;
	}
	return p->buffer[p->front]; 
}
//删除队首的元素
datatype_t* seqlist_remove_first_data(seqlist_t* p){
	if(seqlist_is_empty(p)){
		printf("顺序表为空\n");
		return NULL;
	}
	datatype_t* pre=p->buffer[p->front];
	p->front=(p->front+1)%MAX;
	p->size--;
	return pre;
}

//清空顺序表
void seqlist_clean(seqlist_t* p){
	if(seqlist_is_empty(p)){
                printf("顺序表为空\n");
		return;
	}
	while(!seqlist_is_empty(p)){
		free(p->buffer[p->front]);
		p->front=(p->front+1)%MAX;
		p->size--;
	}
}

seq_list.h

#ifndef __HEAD_SEQ_LIST_H__
#define __HEAD_SEQ_LIST_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <errno.h>

#define MAX 10

typedef struct{
	char name[128];
	char id[128];
	uint8_t age;
}datatype_t;

typedef struct{
	datatype_t* buffer[MAX];
	uint8_t front;
	uint8_t tail;
	uint8_t size;
}seqlist_t;

extern seqlist_t* create_empty_seqlist();
extern bool seqlist_is_full(seqlist_t* p);
extern bool seqlist_insert_data(seqlist_t* p,datatype_t* p_data);
extern bool seqlist_is_empty(seqlist_t* p);
extern datatype_t* seqlist_get_first_data(seqlist_t* p);
extern datatype_t* seqlist_remove_first_data(seqlist_t* p);
extern void seqlist_clean(seqlist_t* p);
#endif