数据结构学习 栈与队列（三）

扑克钓鱼的实现

游戏规则：

轮流出牌，即打出手中的第一张牌放在桌子上

吃牌，即打出的一张牌，在桌子上有一张相同牌就拿走中间全部的牌

先出完牌的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;
}