数据结构学习第二弹 栈与队列(3)

作者: Richie_ll | 来源:发表于2016-07-20 14:16 被阅读182次

    扑克钓鱼的实现

    游戏规则:

    • 轮流出牌,即打出手中的第一张牌放在桌子上
    • 吃牌,即打出的一张牌,在桌子上有一张相同牌就拿走中间全部的牌
    • 先出完牌的GG

    分析:

    把桌子想象成一个栈

    出栈和入栈操作都是在一端进行操作的

    • 把放在桌子上就是可以看成是入栈操作
    • 钓到牌可以看成是出栈操作

    自己手上的牌想象成一个队列

    钓到牌是加到队尾,打出牌是打出第一张牌

    • 打出第一张牌是出队操作
    • 钓到牌就是入队操作

    代码实现:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define ERROR 0
    #define OK 1
    #define MAXSIZE 100
    #define PokerNumber 6
    
    typedef int Status;                 //状态码
    typedef int Poker;                  //扑克牌牌面
    
    typedef struct
    {
        Poker data[MAXSIZE];
        int top;
    }SeqStack;
    SeqStack desk;                      //用栈表示桌面
    int used[15];                       //标记桌面上的扑克牌出现情况
    typedef struct
    {
        Poker data[MAXSIZE];
        int rear;
        int front;
    }SeqQueue;
    SeqQueue player1,player2;           //用队列表示玩家
    
    //游戏部分
    Status GameInit();                      //游戏初始化部分
    Status GameBody();                      //游戏主体部分
    Status GameOver();                      //游戏结束部分
    Status GetPoker(SeqQueue *q);           //发牌操作
    Status PlayerAction(SeqQueue *player);  //玩家操作逻辑
    //栈操作
    Status InitStack(SeqStack *s);          
    int EmptyStack(SeqStack *s);            
    int GetTop(SeqStack *s);                
    Status PushStack(SeqStack *s,Poker e);  
    Status PopStack(SeqStack *s,Poker *e);  
    //队列操作
    Status InitQueue(SeqQueue *q);          
    int EmptyQueue(SeqQueue *q);            
    Status EnQueue(SeqQueue *q,Poker e);    
    Status DeQueue(SeqQueue *q,Poker *e);   
    
    int main(void)
    {
        GameInit();
        GameBody();
        GameOver();
        return 0;
    }
    
    Status GameInit()
    {
        InitStack(&desk);                   //初始化桌面
        InitQueue(&player1);                //初始化玩家1
        InitQueue(&player2);                //初始化玩家2
        memset(used,0,sizeof(used));        //初始化标记数组
    
        //发牌给玩家1
        GetPoker(&player1);
        //发牌给玩家2
        GetPoker(&player2);
        return OK;
    }
    //发牌操作
    Status GetPoker(SeqQueue *q)
    {
        for(int i=0;i<PokerNumber;i++)
        {
            int poker;
            scanf("%d",&poker);
            EnQueue(q,poker);           //发牌即入队
        }
        return OK;
    }
    Status GameBody()
    {
        //当有一个玩家的牌出完时循环结束
        while(!EmptyQueue(&player1) && !EmptyQueue(&player2) )
        {
            PlayerAction(&player1);     //玩家1先手
            PlayerAction(&player2);
        }
        return OK;
    }
    
    Status PlayerAction(SeqQueue *player)
    {
        int GivePoker;
        //先打出一张牌
        DeQueue(player,&GivePoker);
        //判断这张牌有没有被用过
        if(used[GivePoker]==0)
        {
            PushStack(&desk,GivePoker);     //没用过入栈(放到桌子上)
            used[GivePoker] = 1;            //标记表示桌面上已经由这张牌了
        }
        else
        {
            //刚刚打出的牌重新入队
            EnQueue(player,GivePoker);
            while(GetTop(&desk) != GivePoker)
            {
                //找到那张相同的牌为止的中间所有牌都拿起来
                int DeskPoker = GetTop(&desk);
                used[DeskPoker]=0;
                EnQueue(player,DeskPoker);
                PopStack(&desk,&DeskPoker);
            }
        }
        return OK;
    }
    
    Status GameOver()
    {
        if(EmptyQueue(&player1))
            printf("Player2 Win!");
        else
            printf("Player1 Win!");
        return OK;
    }
    
    //栈的基本操作
    Status InitStack(SeqStack *s)
    {
        s->top = -1;
        return OK;
    }
    int EmptyStack(SeqStack *s)
    {
        if(s->top==-1)
            return 1;
        else
            return 0;
    }
    int GetTop(SeqStack *s)
    {
        if(EmptyStack(s))
            return ERROR;
        Poker e = s->data[s->top];
        return e;
    }
    Status PushStack(SeqStack *s,Poker e)
    {
        if(s->top == MAXSIZE-1)
            return ERROR;
        s->top++;
        s->data[s->top] = e;
        return OK;
    }
    Status PopStack(SeqStack *s,Poker *e)
    {
        if(EmptyStack(s))
            return ERROR;
        *e = s->data[s->top];
        s->top--;
        return OK;
    }
    //队列的基本操作
    Status InitQueue(SeqQueue *q)
    {
        q->rear = 0;
        q->front = 0;
        return OK;
    }
    int EmptyQueue(SeqQueue *q)
    {
        if(q->rear == q->front)
            return 1;
        else
            return 0;
    }
    Status EnQueue(SeqQueue *q,Poker e)
    {
        if(q->rear == MAXSIZE)
            return ERROR;
        q->data[q->rear] = e;
        q->rear++;
        return OK;
    }
    Status DeQueue(SeqQueue *q,Poker *e)
    {
        if(EmptyQueue(q))
            return ERROR;
        *e = q->data[q->front];
        q->front++;
        return OK;
    }
    

    相关文章

      网友评论

        本文标题:数据结构学习第二弹 栈与队列(3)

        本文链接:https://www.haomeiwen.com/subject/fppvjttx.html