扑克钓鱼的实现

游戏规则：

• 轮流出牌，即打出手中的第一张牌放在桌子上
• 吃牌，即打出的一张牌，在桌子上有一张相同牌就拿走中间全部的牌
• 先出完牌的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;
}