静态队列、循环队列基本操作

#include <stdio.h>
#include <malloc.h>
//静态队列,循环队列 
typedef struct Queue{
	int * base; 
	int front;//队首
	int rear;//队尾 
	int len;//队列长度 
}QUEUE,*PQUEUE;
void init(PQUEUE);//初始化 
void in(PQUEUE);//入队 
void out(PQUEUE,int *);//出队 
void printQueue(PQUEUE);//打印队列 
bool is_empty(PQUEUE);//队列是否为空 
bool is_full(PQUEUE);//队列是否满 
int main(void){
	QUEUE q;
	int val; 
	init(&q);
	in(&q); 
	in(&q); 
	in(&q); 
	printQueue(&q); 
	out(&q,&val); 
	printf("出队的元素是:%d\n",val); 
	printQueue(&q);
	return 0; 
} 
//队列初始化 
void init(PQUEUE pQ){
	int len;
	printf("请输入需要存储几个元素:");
	scanf("%d",&len); 
	pQ->base =(int*)malloc( sizeof(int)*(len+1) );//因为队尾是最后一个元素的下一个元素,所以要加一 
	if(pQ->base == NULL){
		printf("初始化,分配内存失败."); 
		exit(-1); 
	} 
	pQ->front = pQ->rear = 0; 
	pQ->len = len; 
}
//入队,队首总是指向第一个元素,队尾总是指针最后一个有效元素的下一个元素(一般为NULL) 
void in(PQUEUE pQ){
	if(is_full(pQ)){
		printf("该队列已满,不能入队\n");
		return; 
	} 
	int val;
	printf("请输入值:");
	scanf("%d",&val);
	pQ->base[pQ->rear] = val;
	pQ->rear = (pQ->rear+1)%pQ->len; 
}
//出队 
void out(PQUEUE pQ,int * pVal){
	if( is_empty(pQ) ){
		printf("该队列为空,不能出错\n");
		return; 
	} 
	*pVal = pQ->base[pQ->front];
	pQ->front = (pQ->front+1)%pQ->len; 
}
//打印队列 
void printQueue(PQUEUE pQ){
	if( is_empty(pQ) ){
		printf("该队列为空\n");
		return; 
	} 
	printf("队列的元素为:"); 
	int t = pQ->front; 
	while(t != pQ->rear){
		printf("%d ",pQ->base[t]);
		t = (t+1)%pQ->len; 
	} 
	printf("\n"); 
} 
//判断队列是否为空 
bool is_empty(PQUEUE pQ){
	return pQ->front == pQ->rear; 
} 
//判断队列是否已满 
bool is_full(PQUEUE pQ){
	return (pQ->rear+1)%pQ->len == pQ->front; 
} 

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
循环队列是一种非常常见和实用的数据结构,可用于缓存、队列等场景。可伸缩循环队列则是一种更加灵活的循环队列,可以动态扩展和缩小队列的大小,以适应不同的需求。 制作可伸缩循环队列静态库和动态库,可以方便地在不同的项目中使用该数据结构,提高代码复用性和开发效率。 以下是制作步骤: 1. 定义可伸缩循环队列数据结构 可伸缩循环队列数据结构包含三个重要的变量:队列的容量(capacity)、队列的头指针(front)、队列的尾指针(rear)。可以使用结构体来定义该数据结构,如下所示: ``` typedef struct { int capacity; // 队列的容量 int front; // 队列的头指针 int rear; // 队列的尾指针 int* data; // 队列的数据数组 } SeqQueue; ``` 2. 实现可伸缩循环队列基本操作 可伸缩循环队列基本操作包括入队、出队、判断队列是否为空、判断队列是否已满等。具体实现方法可以参考如下代码: ``` // 创建空队列 SeqQueue* createQueue(int capacity) { SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue)); queue->capacity = capacity; queue->front = 0; queue->rear = 0; queue->data = (int*)malloc(capacity * sizeof(int)); return queue; } // 入队操作 void enqueue(SeqQueue* queue, int value) { if ((queue->rear + 1) % queue->capacity == queue->front) { // 队列已满,需要扩容 int* newData = (int*)malloc(queue->capacity * 2 * sizeof(int)); int j = 0; for (int i = queue->front; i != queue->rear; i = (i + 1) % queue->capacity) { newData[j++] = queue->data[i]; } newData[j++] = queue->data[queue->rear]; free(queue->data); queue->data = newData; queue->front = 0; queue->rear = j % (queue->capacity * 2); queue->capacity = queue->capacity * 2; } queue->data[queue->rear] = value; queue->rear = (queue->rear + 1) % queue->capacity; } // 出队操作 int dequeue(SeqQueue* queue) { if (queue->front == queue->rear) { // 队列为空 return -1; } int value = queue->data[queue->front]; queue->front = (queue->front + 1) % queue->capacity; return value; } // 判断队列是否为空 int isEmpty(SeqQueue* queue) { return queue->front == queue->rear; } // 判断队列是否已满 int isFull(SeqQueue* queue) { return (queue->rear + 1) % queue->capacity == queue->front; } ``` 3. 将可伸缩循环队列封装成静态库和动态库 将上述代码封装成静态库和动态库非常简单,可以使用以下命令: 静态库: ``` gcc -c seqqueue.c ar rcs libseqqueue.a seqqueue.o ``` 动态库: ``` gcc -c -fpic seqqueue.c gcc -shared -o libseqqueue.so seqqueue.o ``` 4. 在其他项目中使用可伸缩循环队列库 使用静态库: ``` gcc main.c -o main -L. -lseqqueue ``` 使用动态库: ``` gcc main.c -o main -L. -lseqqueue -Wl,-rpath=. ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值