文章目录
- 缘起
- 代码地址
- 纸牌游戏
- 分析
- 代码
- 演示
- 优化
缘起
各位小伙伴们好呀，还有几天就要过年了，祝大家新年快乐，万事胜意！
本人最近看了下《啊哈算法》，确实阔以。
但稍显遗憾的是，书籍示例代码是c语言，而不是本人常用的Java。
那就弥补遗憾，说干就干，把这本书的示例语言用java写一遍， 顺带附上一些自己的理解！
于是本篇博客就横空出世了！！！
本篇博客主要是通过一个纸牌游戏的案例，将之前所讲队列和栈的内容组合运用，以便更加深刻的理解：
- Java玩转《啊哈算法》解密QQ号之队列
- Java玩转《啊哈算法》解密回文之栈
来不及买纸质书但又想尽快感受算法魅力的童鞋也甭担心，电子版的下载链接已经放到下方了，可尽情下载。
链接：https://pan.baidu.com/s/1imxiElcCorw2F-HJEnB-PA?pwd=jmgs
提取码：jmgs
代码地址
本文代码已开源：
git clone https://gitee.com/guqueyue/my-blog-demo.git
请切换到gitee分支，
然后查看aHaAlgorithm模块下的src/main/java/com/guqueyue/aHaAlgorithm/chapter_2_StackAndChainTable即可！
纸牌游戏
在书中，作者直接了当的介绍了一款纸牌游戏：
星期天小哼和小哈约在一起玩桌游，他们正在玩一个非常古怪的扑克游戏——“小猫钓鱼”。
游戏的规则是这样的：
将一副扑克牌平均分成两份，每人拿一份。
小哼先拿出手中的第一张扑克牌放在桌上，然后小哈也拿出手中的第一张扑克牌，
并放在小哼刚打出的扑克牌的上面，就像这样两人交替出牌。
出牌时，如果某人打出的牌与桌上某张牌的牌面相同，
即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。
当任意一人手中的牌全部出完时，游戏结束，对手获胜。
假如游戏开始时，小哼手中有 6 张牌，顺序为 2 4 1 2 5 6，小哈手中也有 6 张牌，顺序为 3 1 3 5 6 4，最终谁会获胜呢？
现在你可以拿出纸牌来试一试。接下来请你写一个程序来自动判断谁将获胜。
这里我们做一个约定，小哼和小哈手中牌的牌面只有 1~9。
不知道大家小时候有没有玩过这款纸牌游戏？
反正我小时候是经常玩，只不过我们那里不叫小猫钓鱼，而是叫“排火车”。
当然，也有很多地方叫“拉火车”。大致是因为扑克牌一张一张连起来真的很像一节节的火车呀！
分析
我们来分析一下这个游戏规则，其实这个纸牌游戏非常的简单：
无非就是你一张，我一张；如遇到桌子上有相同的，就把相同的纸牌以及中间的纸牌全部收起来。
而你手上的纸牌是先进先出，明显是 队列；桌子上的纸牌则是先进后出，显然是 栈。
我们只需要用代码模拟出牌流程，边出牌边判断谁的牌没有了，即可判断游戏谁将获胜！
代码
首先，我们创建一个队列类，用于模拟手上的牌：
package com.guqueyue.aHaAlgorithm.entity;
/**
* @Author: guqueyue
* @Description: 队列类 - 通过数组实现
* @Date: 2024/1/11
**/
public class Queue {
public int[] data = new int[1001]; // 数组，用来储存内容
public int head; // 队首
public int tail; // 队尾
/**
* @Description 重写 toString()方法，便于打印查看队列内容
* @Param []
* @return java.lang.String
**/
@Override
public String toString() {
if (this.head == this.tail) {
return "无";
}
String str = "";
int head = this.head, tail = this.tail;
while (head < tail) {
str += data[head++] + " ";
}
return str;
}
}
其次，我们再创建一个栈类，用于模拟桌子上的牌：
package com.guqueyue.aHaAlgorithm.entity;
/**
* @Author: guqueyue
* @Description: 栈 - 通过数组实现
* @Date: 2024/1/12
**/
public class Stack {
public int[] data = new int[10]; // 数组，用来存储栈的内容
public int top; // 栈顶
/**
* @Description 重写 toString()方法，便于打印查看栈内容
* @Param []
* @return java.lang.String
**/
@Override
public String toString() {
if (this.top == 0) {
return "无";
}
String str = "";
int top = this.top;
while (top > 0) {
str += data[--top] + " ";
}
return str;
}
}
因为我们假设牌面为 1-9，所以这里我们数组的长度设置为10即可。
我们需要声明一些变量，用来表示双方的卡牌以及桌子上的牌：
private static Queue q1 = new Queue(); // 小哼手中的牌
private static Queue q2 = new Queue(); // 小哈手中的牌
private static Stack stack = new Stack(); // 桌面上的牌
然后，我们编写一个方法，用来输入读取双方的卡牌：
/**
* @Description 读牌
* @Param []
* @return void
**/
private static void readCard() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入牌数：");
int n = scanner.nextInt();
// 小哼手中的牌
System.out.print("请输入小哼手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q1.data[q1.tail++] = scanner.nextInt();
}
// 小哈手中的牌
System.out.print("请输入小哈手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q2.data[q2.tail++] = scanner.nextInt();
}
}
然后，我们需要模拟双方不断出牌和手牌的过程，直至双方中有人手中无牌（这里是核心逻辑）：
// 循环拿牌放牌，直到有一方无牌
while (q1.head < q1.tail && q2.head < q2.tail) {
// 出牌阶段，小哼先拿牌
int t = q1.data[q1.head];
// 判断桌面是否是相同的牌
boolean flag = judgeCard(t);
// 小哼放牌
giveCard(q1, t);
if (flag) { // 如果有，则拿牌
// 收牌
getCard(q1, t);
}
// 出牌阶段，小哈再出牌
t = q2.data[q2.head];
// 判断桌面是否是相同的牌
flag = judgeCard(t);
// 小哈放牌
giveCard(q2, t);
// 遍历栈，发现是否有相同的牌 - 拿桌面上的牌
if (flag) {
getCard(q2, t);
}
}
在这个过程中，我们还需要一个方法，用来判断出的牌桌面上是否有：
/**
* @Description 判断桌子上是否有相同的牌
* @Param [t: 出的牌]
* @return boolean
**/
private static boolean judgeCard(int t) {
boolean flag = false;
for (int j = 0; j < stack.top; j++) {
if (t == stack.data[j]) {
flag = true;
break;
}
}
return flag;
}
因为小哼和小哈放牌的逻辑是一样的，所以我们也可以抽取出一个方法：
/**
* @Description 出牌
* @Param [q: 需要出牌的队列, t: 出的牌]
* @return int 出的牌
**/
private static void giveCard(Queue q, int t) {
// 放牌到桌子上
q.head++;
stack.data[stack.top++] = t;
}
同样的，收牌我们也可以抽取出一个方法：
/**
* @Description 收牌
* @Param [q: 谁的牌， t: 出的牌]
* @return void
**/
private static void getCard(Queue q, int t) {
// 先拿第一张
q.data[q.tail++] = stack.data[--stack.top];
while (t != stack.data[stack.top-1]) {
// 入队
q.data[q.tail++] = stack.data[--stack.top];
}
// 拿最后一张牌
q.data[q.tail++] = stack.data[--stack.top];
}
最后，我们需要一个方法用来打印最后的结果：
/**
* @Description 打印最后的结果
* @Param []
* @return void
**/
private static void print() {
System.out.println("========================最终结果========================");
System.out.println("小哼： " + q1);
System.out.println("小哈：" + q2);
System.out.println("桌面：" + stack);
// 判断谁赢
System.out.println(q1.head >= q1.tail ? "小哈赢了！" : "小哼赢了");
}
完整代码如下：
package com.guqueyue.aHaAlgorithm.chapter_2_StackAndChainTable;
import com.guqueyue.aHaAlgorithm.entity.Queue;
import com.guqueyue.aHaAlgorithm.entity.Stack;
import java.util.Scanner;
/**
* @Author: guqueyue
* @Description: 纸牌游戏 - 暂且规定牌面只有 1-9
* @Date: 2024/1/12
**/
public class CardGame {
private static Queue q1 = new Queue(); // 小哼手中的牌
private static Queue q2 = new Queue(); // 小哈手中的牌
private static Stack stack = new Stack(); // 桌面上的牌
public static void main(String[] args) {
// 读牌
readCard();
// 循环拿牌放牌，直到有一方无牌
while (q1.head < q1.tail && q2.head < q2.tail) {
// 出牌阶段，小哼先拿牌
int t = q1.data[q1.head];
// 判断桌面是否是相同的牌
boolean flag = judgeCard(t);
// 小哼放牌
giveCard(q1, t);
if (flag) { // 如果有，则拿牌
// 收牌
getCard(q1, t);
}
// 出牌阶段，小哈再出牌
t = q2.data[q2.head];
// 判断桌面是否是相同的牌
flag = judgeCard(t);
// 小哈放牌
giveCard(q2, t);
// 遍历栈，发现是否有相同的牌 - 拿桌面上的牌
if (flag) {
getCard(q2, t);
}
}
// 打印最后的结果
print();
}
/**
* @Description 读牌
* @Param []
* @return void
**/
private static void readCard() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入牌数：");
int n = scanner.nextInt();
// 小哼手中的牌
System.out.print("请输入小哼手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q1.data[q1.tail++] = scanner.nextInt();
}
// 小哈手中的牌
System.out.print("请输入小哈手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q2.data[q2.tail++] = scanner.nextInt();
}
}
/**
* @Description 判断桌子上是否有相同的牌
* @Param [t: 出的牌]
* @return boolean
**/
private static boolean judgeCard(int t) {
boolean flag = false;
for (int j = 0; j < stack.top; j++) {
if (t == stack.data[j]) {
flag = true;
break;
}
}
return flag;
}
/**
* @Description 出牌
* @Param [q: 需要出牌的队列, t: 出的牌]
* @return int 出的牌
**/
private static void giveCard(Queue q, int t) {
// 放牌到桌子上
q.head++;
stack.data[stack.top++] = t;
}
/**
* @Description 收牌
* @Param [q: 谁的牌， t: 出的牌]
* @return void
**/
private static void getCard(Queue q, int t) {
// 先拿第一张
q.data[q.tail++] = stack.data[--stack.top];
while (t != stack.data[stack.top-1]) {
// 入队
q.data[q.tail++] = stack.data[--stack.top];
}
// 拿最后一张牌
q.data[q.tail++] = stack.data[--stack.top];
}
/**
* @Description 打印最后的结果
* @Param []
* @return void
**/
private static void print() {
System.out.println("========================最终结果========================");
System.out.println("小哼： " + q1);
System.out.println("小哈：" + q2);
System.out.println("桌面：" + stack);
// 判断谁赢
System.out.println(q1.head >= q1.tail ? "小哈赢了！" : "小哼赢了");
}
}
演示
我们启动上文的代码，运行程序，可得：
哦，看来是小哈赢了。诶，等等，这个时候看过原书的小伙伴可能就要说了(不过我猜，压根没有 )
：你这个跟书上的结果不太一样呀？
其实是因为书上的程序并没有拿回桌面上相同的那张牌。
我们把拿回桌面上相同的那张牌的代码注释：
再次运行程序，可得：
这样的结果跟书上就一致了。
但是，这个并不符合作者所描述的游戏规则：
如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。
不知道是作者粗心大意，还是有意为之。
优化
当然，这上面的代码还有一定的优化空间。
比如，如何判断桌面上是否有牌？我们在上文中是直接循环栈来判断的。
但是，在循环里面嵌套循环其实是非常占用时间复杂度的。
我们这里直接声明一个数组，用来表示桌面上是否有牌：
private static int[] book = new int[10]; // 用来标记桌面上的牌是否存在
然后，放牌的时候标记：
取牌的时候取消标记即可：
下面是完整代码：
package com.guqueyue.aHaAlgorithm.chapter_2_StackAndChainTable;
import com.guqueyue.aHaAlgorithm.entity.Queue;
import com.guqueyue.aHaAlgorithm.entity.Stack;
import java.util.Scanner;
/**
* @Author: guqueyue
* @Description: 纸牌游戏 - 暂且规定牌面只有 1-9 - 优化版
* @Date: 2024/1/12
**/
public class CardGame2 {
private static Queue q1 = new Queue(); // 小哼手中的牌
private static Queue q2 = new Queue(); // 小哈手中的牌
private static Stack stack = new Stack(); // 桌面上的牌
private static int[] book = new int[10]; // 用来标记桌面上的牌是否存在
public static void main(String[] args) {
// 读牌
readCard();
// 循环拿牌放牌，直到有一方无牌
while (q1.head < q1.tail && q2.head < q2.tail) {
// 出牌阶段，小哼先拿牌
int t = q1.data[q1.head];
// 判断桌面是否是相同的牌
boolean flag = book[t] == 1;
// 小哼放牌
giveCard(q1, t);
if (flag) { // 如果有，则拿牌
// 收牌
getCard(q1, t);
}
// 出牌阶段，小哈再出牌
t = q2.data[q2.head];
// 判断桌面是否是相同的牌
flag = book[t] == 1;
// 小哈放牌
giveCard(q2, t);
// 遍历栈，发现是否有相同的牌 - 拿桌面上的牌
if (flag) {
getCard(q2, t);
}
}
// 打印最后的结果
print();
}
/**
* @Description 读牌
* @Param []
* @return void
**/
private static void readCard() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入牌数：");
int n = scanner.nextInt();
// 小哼手中的牌
System.out.print("请输入小哼手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q1.data[q1.tail++] = scanner.nextInt();
}
// 小哈手中的牌
System.out.print("请输入小哈手中的牌（1-9），中间空格隔开，再按回车：");
for (int i = 0; i < n; i++) {
q2.data[q2.tail++] = scanner.nextInt();
}
}
/**
* @Description 出牌
* @Param [q: 需要出牌的队列, t: 出的牌]
* @return int 出的牌
**/
private static void giveCard(Queue q, int t) {
// 放牌到桌子上
q.head++;
stack.data[stack.top++] = t;
// 标记
book[t] = 1;
}
/**
* @Description 收牌
* @Param [q: 谁的牌， t: 出的牌]
* @return void
**/
private static void getCard(Queue q, int t) {
// 先拿第一张
book[stack.data[stack.top-1]] = 0; // 取消标记
q.data[q.tail++] = stack.data[--stack.top];
while (t != stack.data[stack.top-1]) {
book[stack.data[stack.top-1]] = 0; // 取消标记
// 入队
q.data[q.tail++] = stack.data[--stack.top];
}
// 拿最后一张牌
book[stack.data[stack.top-1]] = 0; // 取消标记
q.data[q.tail++] = stack.data[--stack.top];
}
/**
* @Description 打印最后的结果
* @Param []
* @return void
**/
private static void print() {
System.out.println("========================最终结果========================");
System.out.println("小哼： " + q1);
System.out.println("小哈：" + q2);
System.out.println("桌面：" + stack);
// 判断谁赢
System.out.println(q1.head >= q1.tail ? "小哈赢了！" : "小哼赢了");
}
}
运行：
搞定。
