球钟（利用栈和队列实现）

最新推荐文章于 2022-11-19 06:30:00 发布
原创 最新推荐文章于 2022-11-19 06:30:00 发布 · 400 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言 #栈 #队列

什么是球钟

球钟是一个利用球的移动来记录时间的简单装置
它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器
例如：分钟指示器中有2个球，五分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32

工作原理

每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。
当放入第五个球时，在分钟指示器的4个球就会按照他们被放入时的相反顺序加入球队列的队尾。而第五个球就会进入五分钟指示器。
按此类推，五分钟指示器最多可放11个球，小时指示器最多可放11个球。
当小时指示器放入第12个球时，原来的11个球按照他们被放入时的相反顺序加入球队列的队尾，然后第12个球也回到队尾。这时，三个指示器均为空，回到初始状态，从而形成一个循环。因此，该球钟表示时间的范围是从0：00到11：59。

目标

现设初始时球队列的球数为27，球钟的三个指示器初态均为空。问，要经过多久，球队列才能回复到原来的顺序？

实现程序

实现球钟需要用到栈和队列
为了方便使用创建了两个库文件
linkqueue.h和sqstack.h
在程序中栈使用的是顺序栈、队列为链式队列。

顺序栈的实现

linkqueue.h代码
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef int data_t;

typedef struct node{
data_t data;
struct node *next;
}node,*linknode;

typedef struct{
linknode front;
linknode reat;
}queue,*linkqueue;

linkqueue queue_creart();
int queue_push(linkqueue Q,data_t data);
int queue_pop(linkqueue Q);
linkqueue queue_free(linkqueue Q);
int queue_show(linkqueue Q);
linkqueue.c代码
#include"linkqueue.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*里边被注释的 printf("")不注释可以看见程序每一步的实现但比较多，会显示几千行*/

linkqueue queue_creart(){
	linknode H;
	linkqueue Q;
	H = (linknode)malloc(sizeof(node));
	if(H == NULL){
		printf("H malloc is filed\n");
		return NULL;
	}
	Q = (linkqueue)malloc(sizeof(queue));
	if(Q == NULL){
		printf("Q malloc is filed\n");
		return NULL;
	}
	H->data = 0;
	H->next = NULL;
	Q->front = Q->reat = H;
	return Q;
}
int queue_push(linkqueue Q,data_t data){
	linknode H;
	H = (linknode)malloc(sizeof(node));
	if(H == NULL){
		printf("H malloc is failed\n");
		return -1;
	}
	H->data = data;
	H->next = Q->reat->next;
	Q->reat->next = H;
	Q->reat = H;
//	printf("the data %d push in queue\n",data);
	return 0;
}
int queue_pop(linkqueue Q){
	linknode p;
	data_t data;
	if(Q->front == Q->reat){
		printf("queue is NULL\n");
		return -1;
	}
	
//	printf("%3d",Q->front->next->data);
	data = Q->front->next->data;
	p = Q->front;
	Q->front = Q->front->next;
	free(p);
	p = NULL;


	return data;
}
linkqueue queue_free(linkqueue Q){
	linknode p;

	while(Q->front){
		p = Q->front;
//		printf("free %d\n",p->data);
		Q->front = Q->front->next;
		free(p);
		p = NULL;
	}
	free(Q);
	Q = NULL;
	return NULL;
}

int queue_show(linkqueue Q){
	linknode p;
	p = Q->front;
	while(1){
		if(p->next == NULL){
			break;
		}
		printf("%3d",p->next->data);
		p = p->next;
	}
	puts("");
	return 0;
}

链式队列的实现

sqstack.h代码
#include<stdio.h>

typedef int data_t;
typedef struct{
	data_t *data;
	int maxlen;
	int top;
}sqstack,*linstack;

linstack stack_creart(int len); //creart stack
int stack_push(linstack S,data_t data); //push of stack
int stack_pop(linstack S); //pop of stack
int stack_seek_data(linstack S,data_t data); //seek stack of data
data_t stack_seek_seat(linstack S,int seat); //seek stack of seat
int stack_long(linstack S); //how many data of stack
linstack stack_free(linstack S); //clear stack
int stack_show(linstack S); // show of stack
int stack_empty(linstack S); //the stack is NULL
int stack_clear(linstack S);
sqstack.c代码
#include"sqstack.h"
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/*里边被注释的 printf("")不注释可以看见程序每一步的实现但比较多，会显示几千行*/
linstack stack_creart(int len){ //creart stack

	//	return NULL;
	linstack S;

	S = (linstack)malloc(sizeof(sqstack));
	S->data = (data_t *)malloc(len * sizeof(data_t));
	if(S == NULL || S->data == NULL){
		return NULL;
	}

	//memset(S,0,sizeof(sqstack));
	memset(S->data,0,(len * sizeof(data_t)));
	S->maxlen = len;
	S->top = -1;

	return S;
}

int stack_push(linstack S,data_t data){ //push of stack
	if(S->top == S->maxlen-1){
	//	printf("the stack is full\n");
		return -1;
	}
	S->top++;
	S->data[S->top] = data;
//	printf("the data %d is push in stack\n",data);
	return 0;
}

int stack_pop(linstack S){ //pop of stack
	if(S->top == -1){
	//	printf("the stack is NULL\n");
		return -1;
	}
	if(S == NULL){
	//	printf("S is NULL");
		return -1;
	}
/*	while(S->top > -1){
		printf("%3d",S->data[S->top]);
		S->top--;
	}*/

//printf("%3d",S->data[S->top]);
//S->top--;
	return S->data[S->top];
}

int stack_seek_data(linstack S,data_t data){ //seek stack of data

	return 0;
}

data_t stack_seek_seat(linstack S,int seat){ //seek stack of seat

	return 0;
}

int stack_long(linstack S){ //how many data of stack
	if(S == NULL){
		printf("S is NULL\n");
		return -1;
	}

	return S->top+1;
}

linstack stack_free(linstack S){ //clear stack
	if(S == NULL){
		return NULL;
	}
	free(S);
	return NULL;
}
int stack_show(linstack S){ //show of stack
	int i = S->top;

	if(S == NULL){
		printf("S is NULL\n");
		return -1;
	}
	while(i >= 0){
		printf("%3d",S->data[i]);
		i--;
	}
	puts("");
	return 0;
}

/*
 *ret 0 stack is null;1 stack no null
 * */
int stack_empty(linstack S){ //the stack is NULL
	if(S == NULL){
		printf("S is NULL\n");
		return -1;
	}
	return (S->top == -1? 0 : 1);
}


int stack_clear(linstack S){
	S->top = -1;
	return 0;
}

球钟的实现

clock.c代码
#include<stdio.h>
#include"linkqueue.h"
#include"sqstack.h"

int min_push_Q(linstack min,linkqueue Q);
int min_5_push_Q(linstack min_5,linkqueue Q);
int hour_push_Q(linstack hour,linkqueue Q);
int check(linkqueue Q);

int main(){
	linkqueue Q;
	linstack hour,min_5,min;
	int i,j,k,m,n;
	n = 0;
	Q = queue_creart();
	hour = stack_creart(11);
	min_5 = stack_creart(11);
	min = stack_creart(4);
	if(Q == NULL || min_5 == NULL || min == NULL || Q == NULL){
		printf("hour or min_5 or min or Q is NULL\n");
		return -1;
	}

	for(i = 1;i <= 27;i++){
		queue_push(Q,i);
	}

	while(1){
		n++;
		i = queue_pop(Q);
		//	sleep(1);
		j = stack_push(min,i);
		if(j == -1){
			min_push_Q(min,Q);
			k =stack_push(min_5,i);
			if(k == -1){
				min_5_push_Q(min_5,Q);
				m = stack_push(hour,i);
				if(m == -1){
					hour_push_Q(hour,Q);
					queue_push(Q,i);
					if(check(Q) == 1){
						printf("Q:");
						queue_show(Q);
						printf("min %d\n",n);
						break;
					}
				}
			}
		}
	}

	//	printf("Q:");
	//	queue_show(Q);
	//	printf("min:");
	//	stack_show(min);
	//	printf("min_5:");
	//	stack_show(min_5);
	//	printf("hour:");
	//	stack_show(hour);
	queue_free(Q);
	stack_free(min_5);
	stack_free(min);
	return 0;
}

int min_push_Q(linstack min,linkqueue Q){
	int i;
	while(1){
		i = stack_pop(min);
		if(i == -1){
			return 0;
		}
		min->top--;
		queue_push(Q,i);
	}
}

int min_5_push_Q(linstack min_5,linkqueue Q){
	int i;
	while(1){
		i = stack_pop(min_5);
		if(i == -1){
			return 0;
		}
		min_5->top--;
		queue_push(Q,i);
	}
}

int hour_push_Q(linstack hour,linkqueue Q){
	int i;
	while(1){
		i = stack_pop(hour);
		if(i == -1){
			return 0;
		}
		hour->top--;
		queue_push(Q,i);
	}
}

int check(linkqueue Q){
	linknode p;
	p = Q->front->next;
	while(p && p->next){
		if(p->data < p->next->data){
			p = p->next;
		}
		else{
			return 0;
		}
	}
	return 1;
}
结果
ubuntu-14-zs@ubuntu:~/1024/datastruct/clock$ ./clock
Q:  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
min 33120
/*经历了33120分钟球队列才能回复到原来的顺序*/

代码不足之处太多，还请各位大佬多多指教。

数据结构（C语言）-球钟问题（栈和队列）-学习笔记05
baidu_41924187的博客
06-09 394
1. 球钟背景 球钟是一个利用球的移动来记录时间的简单装置 它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器 若分钟指示器中有两个球，五分钟指示器有六个球，小时指示器有五个球，那就代表时间是5：32 2. 工作原理 我们需要27个球放入一个队列 需要三个栈，分别代表分钟指示器，五分钟指示器，小时指示器 每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可以容纳四个球 放入第五个球的时候，分钟指示器清空，也就是把分钟指示器中的四个球按照被放入时的相反顺序加入到球队
球钟——使用c语言编程实现
01-12
设计算法实现球钟，使用c语言编写，不足之处请多多谅解
数据结构与算法：球钟问题
jiangrang1的博客
07-24 825
数据结构与算法：球钟问题
球钟问题
qq_40844674的博客
03-29 561
球钟问题 问题描述:球钟是利用球的移动来记录时间的装置。 它有三个可以容纳若干个球的容器：分钟指示器，五分钟指示器，小时指示器。若分钟指示器中有2个球，5分钟指示器中有3个球，小时指示器中有4个球，则时间为4:17。 每过一分钟，球钟就会从球队列（先进先出）的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。在放进去第五个球的时候，分钟指示器内的4个球就会按照他们被放入时的相反顺序加入球队列的队尾（先进后出：栈）。而第五个球就会进入五分钟指示器（五进制）。 按此类推，五分钟指示器最多可放
球钟代码
ZHYFXY的博客
03-23 684
#include #include #define ONEMIN 5 #define FIVEMIN 12 #define ONEHOUR 12 #define BALLQUE 28 #define OK 1 #define ERROR 0 typedef int data_t; typedef struct { data_t *data; int top;//栈顶 in
球钟问题(栈和队列的应用)
w9521423的博客
10-03 1220
*/#include#include#include#define N 30                                                            /*27#define NULL 0typedef struct Qnode                                              /*定义队列的接点类型*/{int
利用队列和栈解决球钟问题
09-13
通过队列与栈解决球钟问题。球钟问题是：分钟指示器最多容纳4个球，5分钟指示器最多容纳11个球，小时计时器最多容纳11个球。还有一个包含27个球的队列，每分钟向分钟计时器输送一个球，如果满，分钟计时器内的球倒序...
C++实现小球钟：栈与队列解决奥赛难题
在这个问题中，程序员需要实现栈和队列的数据结构，并利用它们来解决特定的算法挑战。 在提供的代码片段中，可以看到两个类：`stack` 和 `queue`，分别代表栈和队列。栈是一种后进先出（LIFO）的数据结构，而队列是...
球钟问题（用链式栈和链式队列实现）
07-31
球钟是一个利用球的移动来记录时间的简单装置。它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器。若分钟指示器中有2个球，5分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32。
使用栈和队列巧妙解决球钟难题
标题中的“球钟问题解决”指的是利用计算机科学中的数据结构——栈（Stack）和队列（Queue）来解决一个具体的问题，通常这个“球钟”是指一种机械装置，用于控制时间。在计算机科学领域，球钟问题可以通过模拟球的...
数据结构 球钟问题
03-19
用c编写 数据结构中的球钟问题 实现用球表示时间 有一分球 五分球 一个小时球 实现00:00~11:59的表示
C语言球钟问题
u010916862的博客
04-14 1600
在数据结构的栈和队列的学习过程中，除了需要了解栈、队列的基本特点外，需要掌握包括创建、出栈入栈、出队入队等基本操作。并熟悉一些常见的应用问题，比如球钟问题就是一个典型利用栈和队列实现的实际问题。本文描述球钟问题的具体实现过程。球钟是一个利用球的移动来记录时间的简单装置.它有三个可以容纳若干个球的指示器：分钟指示器,五分钟指示器,小时指示器.若分钟指示器中有2个球,五分钟指示器中有6个球,小时指示器
数据结构 球钟问题
Phoenix_qsr的博客
10-03 701
学到数据结构时，遇到一个题目：球钟 问题描述:球钟是利用球的移动来记录时间的装置（吐槽：这么麻烦，球会准时放进去？）。它有三个可以容纳若干个球的容器：分钟指示器，五分钟指示器，小时指示器。若分钟指示器中有2个球，5分钟指示器中有3个球，小时指示器中有4个球，则时间为4:17。每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。在放进去第五个球的时候，分钟指示器内...
C语言解决球钟问题:
长江不择细流，故能浩荡万里
03-08 1452
球钟问题描述: 球钟是一个利用球的移动来记录时间的简单装置。 它有三个可以容纳若干个球的指示器：分钟指示器，五分钟指示器，小时指示器。 若分钟指示器中有2个球，5分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32。      工作原理:每过一分钟球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。 当放入第五个球时，按在分钟指示器的4个球就会照他们被放
钟球问题——栈和队列的应用
qq_43441284的博客
11-19 474
球钟问题：球钟是利用球的移动来记录时间的装置有三个可以容纳若干球的容器，分别是：分钟指示器、5分钟指示器、小时指示器，当分钟指示器里面有4个球，5分钟指示器里面有1个球，小时指示器里面有一个球，现在的时间就是一小时9分钟。
球钟问题---栈与队列的应用
羟基与苯的博客
04-16 743
文章目录🍔球钟问题描述🍔球钟问题分析🍔代码实现 本文中涉及的代码已提交至Gitee，可以点击链接参考。 鄙人乃一介初学者，文中及代码中难免出错，恳请同志们批评指正！ 🍔球钟问题描述 球钟是一个利用球的移动来记录时间的简单装置，它有三个可以容纳若干个球的指示器：分钟指示器、五分钟指示器、小时指示器。若分钟指示器中有2个球，五分钟指示器中有6个球，小时指示器中有5个球，则时间为5:32。 其工作原理是：每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。当放入第
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值