球钟问题(队列，栈)

问题描述:

球钟是利用球的移动来记录时间的装置，它有三个可以容纳若干个球的容器：分钟指示器，五分钟指示器，小时指示器。若分钟指示器中有2个球，5分钟指示器中有3个球，小时指示器中有4个球，则时间为4:17。每过一分钟，球钟就会从球队列的队首取出一个球放入分钟指示器，分钟指示器最多可容纳4个球。在放进去第五个球的时候，分钟指示器内的4个球就会按照他们被放入时的相反顺序加入球队列的队尾。而第五个球就会进入五分钟指示器。按此类推，五分钟指示器最多可放11个球，小时指示器最多可放11个球。因此，该球种表示的时间范围是从00:00到11:59

方法：

1. 创建三个链式栈，分别保存小时指示器，五分指示器，分钟指示器

2. 创建一个链式循环队列保存1-27小球

3. 从队列中出小球入栈到对应栈。当条件满足栈中小球出栈并入队列，两者循环。

效果展示：

代码：

#include <stdio.h>
#include <stdlib.h>
//宏定义
#define minite 4
#define five_minite 11
#define hour 11 
#define num 28

//结构体定义
typedef struct st_node
{
    int data;
    struct st_node *next;
}node,*node_p;

typedef struct st_stack
{
    int n;
    node_p top;
}stack,*stackp;

typedef struct queue_st
{
    int a[num];
    int front;
    int rear;
}queue;

/***********************************
 *功能:队列创建
 ***********************************/
queue *createqueue()
{
    queue *s=NULL;
    s=(queue *)malloc(sizeof(queue));
    if(s==NULL)
    {
        printf("malloc error!\n");
        return NULL;
    }
    s->front=0;
    s->rear=0;
    return s;
}
/***********************************
 *功能:队列判空
 ***********************************/
int queueempty(queue *s)
{
    return s->front==s->rear?1:0;
}
/***********************************
 *功能:队列判满
 ***********************************/
int queuefull(queue *s)
{
    return (s->rear+1)%num==s->front?1:0;
}

/***********************************
 *功能:队列入队
 ***********************************/
int queue_in(queue *s,int data)
{
    if(queuefull(s))
    {
        printf("the queue is full!\n");
        return -1;
    }
    s->a[s->rear]=data;
    s->rear=(s->rear+1)%num;
}
/***********************************
 *功能:队列出队
 ***********************************/
int queue_out(queue *s)
{
    int ret=0;
    if(queueempty(s))
    {
        printf("the queue is empty!\n");
        return -1;
    }
    ret=s->a[s->front];
    s->front=(s->front+1)%num;
    return ret;
}
/***********************************
 *功能:队列打印
 ***********************************/
int show_queue(queue *s)
{
    int i=s->front;
    for(;i!=s->rear;i=(i+1)%num)
    {
        printf("%d ",s->a[i]);
    }
    printf("\n");
}
/***********************************
 *功能:队列遍历判定是否还原
 ***********************************/
int queue_traverl(queue *s,int flag)
{
    int i=0;
    int j=s->front;
    for(i=1;i<28;i++)
    {
        if(s->a[j]==i)
            j=(j+1)%num;
        else

            break;
    }
    if(i==28)
    {
        printf("顺序回原：");
        show_queue(s);
        printf("经过%d分钟队列完全回原\n",flag);
    }
}
/***********************************
 *功能:链式栈创建
 ***********************************/
stackp creatstack()
{
    stackp s=NULL;

    s=(stackp)malloc(sizeof(stack));
    if(s==NULL)
    {
        printf("malloc error1\n");
        return NULL;
    }
    s->top=NULL;
    s->n=0;
    return s;
}
/***********************************
 *功能:栈判空
 ***********************************/
int empty_stack(stackp s)
{
    return s->top==NULL?1:0;
}
/***********************************
 *功能:入栈
 ***********************************/
int stack_in(stackp s,int data)
{
    node_p p=NULL;
    p=(node_p)malloc(sizeof(node));
    if(p==NULL)
    {
        printf("malloc error!\n");
        return -1;
    }
    p->next=s->top;
    s->top=p;
    p->data=data;
    s->n++;
}
/***********************************
 *功能:出栈
 ***********************************/
int stack_out(stackp s)
{
    if(empty_stack(s))
    {
        printf("the stack is empty!\n");
        return -1;
    }
    node_p p=NULL;
    int ret=0;
    p=s->top;
    ret=p->data;
    s->top=s->top->next;
    free(p);
    s->n--;
    return ret;
}
/***********************************
 *功能:清空栈
 ***********************************/
int clear_stack(stackp s,queue *q)
{
    int a;
    int i=s->n;
    for(;i>0;i--)
    {
        a=stack_out(s);
        queue_in(q,a);
    }
}
/***********************************
 *功能:主函数
 ***********************************/
int main()
{
    int qd=0;
    int md=0,fd=0,hd=0;
    int xunhuan=0;
    int flag=0;
    //创建队列
    queue *s=createqueue();
    //循环入栈1-27
    for(qd=0;qd<27;qd++)
    {
        queue_in(s,qd+1);
    }
    //创建栈
    stackp m=creatstack();//一分栈
    stackp f=creatstack();//五分栈
    stackp h=creatstack();//小时栈

    printf("请输入一个需要换算的分钟数:\n");
    scanf("%d",&xunhuan);
    /*输入数据（多少分钟），开始循环*/

    while(xunhuan--)//进行判断，时分秒循环
    {
        //依次出队列
        qd=queue_out(s);
        //确定入哪个栈或者是否需要清空栈等
        if(m->n<minite)
            stack_in(m,qd);
        else
        {   
            if(f->n<five_minite)
            {
                clear_stack(m,s);
                stack_in(f,qd);
            }
            else
            {
                if(h->n<hour)
                {
                    clear_stack(m,s);
                    clear_stack(f,s);
                    stack_in(h,qd);
                }
                else
                {
                    clear_stack(m,s);
                    clear_stack(f,s);
                    clear_stack(h,s);
                    queue_in(s,qd);
                }
            }
        }
        flag++;
        queue_traverl(s,flag);
    }
    printf("换算后:\n%d:%d\n",h->n,f->n*5+m->n);
}