Java玩转《啊哈算法》纸牌游戏之小猫钓鱼

2024-02-07 21:20
文章标签 java 算法 游戏 玩转 啊哈 纸牌 钓鱼 小猫

本文主要是介绍Java玩转《啊哈算法》纸牌游戏之小猫钓鱼，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

缘起性空

文章目录

  • 缘起
  • 代码地址
  • 纸牌游戏
    • 分析
    • 代码
    • 演示
    • 优化

缘起

各位小伙伴们好呀，还有几天就要过年了，祝大家新年快乐，万事胜意！

本人最近看了下《啊哈算法》，确实阔以。

但稍显遗憾的是，书籍示例代码是c语言，而不是本人常用的Java。

那就弥补遗憾，说干就干，把这本书的示例语言用java写一遍， 顺带附上一些自己的理解！

于是本篇博客就横空出世了！！！

在这里插入图片描述

本篇博客主要是通过一个纸牌游戏的案例，将之前所讲队列和栈的内容组合运用，以便更加深刻的理解：

  1. Java玩转《啊哈算法》解密QQ号之队列
  2. 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**/@Overridepublic 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**/@Overridepublic 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 ? "小哈赢了！" : "小哼赢了");}
}

运行：
在这里插入图片描述

搞定。

这篇关于Java玩转《啊哈算法》纸牌游戏之小猫钓鱼的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/688970。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2