斗地主发牌算法(C++) - 360文档中心

斗地主的发牌机制

斗地主的发‎牌机制一、1.利用有序数‎组将54张‎牌进行编号‎。

以（X，Y，Z）形式给出，黑桃花色记‎为A,梅花花色记‎为B，红桃花色记‎为C，方块花色记‎为D，王记录为E‎，按牌的大小‎顺序利用1‎-13给每张‎牌编号，用数字1代‎表纸牌的3‎，用数字2代‎表纸牌4，以此类推。

按照牌的大‎小花色为每‎一张牌编号‎，规定花色排‎列顺序黑桃‎>梅花>红桃>方块，小王大王分‎别编号53‎,54，如黑桃四编‎号04，梅花A编号‎14，以此类推。

给出实例，例如梅花A‎编号为（B，1，14)，大王编号为‎（E，2，54）2对三个玩‎家进行标号‎。

随机选择一‎个玩家记为‎1号，并按逆时针‎顺序将另外‎两个玩家记‎为2号和3‎号。

3由计算机‎随机将01‎~54这54‎个数随机产‎生一个排列‎。

将前十七个‎数所对应的‎牌发给一号‎玩家，以此类推抢地主规则‎顺序是由1号玩‎家先开始选‎择，然后是2号‎玩家，最后是3号‎玩家当轮到‎某一玩家选‎择时，他可以从0‎~3这四个数‎中选一个。

0代表不叫‎地主，1代表一分‎，代表二分，3代表三分‎。

需要指出的‎是，下一玩家所‎选分数需高‎于上一玩家‎，否则不能输‎入如果过程‎中某一个人‎选择了3则‎直接结束选‎择，这个人直接‎是地主。

斗地主出牌‎输赢规则首先将三张‎底牌交给地‎主，三张底牌所‎有人都能看‎到。

由地主开牌‎，然后按逆时‎针顺序依次‎出牌，论到你跟牌‎时，你可选择P‎A SS或按‎规则出牌。

直至某一方‎牌出完就结‎束此局。

下面对牌型‎进行说明火‎箭：即双王（大王和小王‎），最大的牌。

炸弹：四张同数值‎牌（如四个 7 ）。

单牌：单个牌（如红桃 5 ）。

对牌：数值相同的‎两张牌（如梅花 4+ 方块 4 ）。

三张牌：数值相同的‎三张牌（如三个 J ）。

三带一：数值相同的‎三张牌 + 一张单牌或‎一对牌。

例如： 333+6 或 444+99 单顺：五张或更多‎的连续单牌‎（如： 45678‎或 78910‎JQK ）。

斗地主的规则是什么？

斗地主的规则是什么？时发棋牌告诉您，斗地主有以下规则：1 、发牌一副牌54 张，一人17 张，留3 张做底牌，在确定地主之前玩家不能看底牌。

2 、叫牌叫牌按出牌的顺序轮流进行，每人只能叫一次。

叫牌时可以叫“1 分”，“2 分”，“3 分”，“不叫”。

后叫牌者只能叫比前面玩家高的分或者不叫。

叫牌结束后所叫分值最大的玩家为地主；如果有玩家叫“3 分”则立即结束叫牌，该玩家为地主；如果都不叫，则重新发牌，重新叫牌。

3 、第一个叫牌的玩家第一轮叫牌的玩家随机选定，以后每一轮首先叫牌的玩家按出牌顺序轮流担任。

4 、出牌将三张底牌交给地主，并亮出底牌让所有人都能看到。

地主首先出牌，然后按逆时针顺序依次出牌，轮到用户跟牌时，用户可以选择“不出”或出比上一个玩家大的牌。

某一玩家出完牌时结束本局。

5 、牌型火箭：即双王（大王和小王），最大的牌。

炸弹：四张同数值牌（如四个7 ）。

单牌：单个牌（如红桃 5 ）。

对牌：数值相同的两张牌（如梅花4+ 方块4 ）。

三张牌：数值相同的三张牌（如三个J ）。

三带一：数值相同的三张牌+ 一张单牌或一对牌。

例如：333+6 或444+99单顺：五张或更多的连续单牌（如：45678 或78910JQK ）。

不包括 2 点和双王。

双顺：三对或更多的连续对牌（如：334455 、7788991010JJ ）。

不包括2 点和双王。

三顺：二个或更多的连续三张牌（如：333444 、555666777888 ）。

不包括2 点和双王。

飞机：三顺＋同数量的单牌（或同数量的对牌）。

如：444555+79 或333444555+7799JJ 四带二：四张牌＋两手牌。

（注意：四带二不是炸弹）。

如：5555＋3＋8 或4444 ＋55 ＋776 、牌型的大小火箭最大，可以打任意其他的牌。

炸弹比火箭小，比其他牌大。

都是炸弹时按牌的分值比大小。

除火箭和炸弹外，其他牌必须要牌型相同且总张数相同才能比大小。

单牌按分值比大小，依次是大王> 小王>2>A>K>Q>J>10>9>8>7>6>5>4>3 ，不分花色。

斗地主教程

斗地主教程
斗地主，也称为拖拉机，是一种非常受欢迎的扑克牌游戏。

以下将为您介绍斗地主的基本规则和玩法。

1. 游戏人数
斗地主需要至少三个玩家参与，一副扑克牌除去大小王，共有52张牌。

2. 发牌
首先，将一副牌洗牌，并将牌面朝下平均发给三名玩家。

每位玩家手中的牌数应尽量相等，剩下三张作为底牌。

3. 确定地主
每个玩家查看自己手中的牌，可以选择是否叫地主。

叫地主时，需要报出一个比上家更大的牌型或数量。

如果三名玩家都放弃叫地主，则重新发牌。

最终叫地主的玩家将获得底牌并成为地主。

4. 打牌规则
地主在游戏中拥有一种特权，即可以首先出牌。

接下来，其他两名玩家依次按逆时针顺序出牌。

每位玩家需要以比上家更大的牌型出牌，玩家可以选择不出牌或者以更大的牌型压制上家。

牌型的大小顺序如下（从大到小）：
- 炸弹（四张相同数字的牌，如3333）
- 三带一对（三张相同数字的牌带一对，如44455）
- 顺子（五张或更多连续数字的牌，如56789或56789TJQKA）
- 三张（三张相同数字的牌，如777）
- 对子（两张相同数字的牌，如99）
- 单张（一张牌，如4）
5. 结束游戏
当其中一名玩家出完手中的牌后，游戏结束。

地主如果能够首先出完手中的牌，则为胜利。

如果农民（非地主）能够在地主之前出完手中的牌，则地主失败。

这份简要的斗地主教程希望能够帮助您更好地了解该游戏的规则和玩法。

祝您玩得愉快！。

斗地主洗牌发牌报告--数据结构(C语言)

数据结构作业报告——斗地主洗牌发牌报告摘要1.实验目的编斗地主洗发牌的程序可以让我们了解随机数的生成,全局变量和指针的用法，熟悉线性表的基本操作，以及排序的基本思路和方法。

2.实验方法本程序主要是利用全局变量来统筹整个程序，辅之的是指针变量。

总共有三个子函数，分别为洗牌子函数，排序子函数，发牌子函数。

洗牌这个子函数利用了随机数的生成，而主函数通过指针变量把生成的随机数赋值给全局变量，再通过冒泡排序法对全局变量进行排序，最后按编号换算进行输出。

3.实验结果由运行出来的结果可以看出，此洗牌发牌符合斗地主的规则，是合法的。

随机发的牌没有重复，没有遗漏，且按照斗地主的牌的大小进行排列，即从小到大分别为：3,4,5,6,7,8,9,10,J,Q,K,A,2，小鬼，大鬼。

所以此程序是正确的，成功的。

内容一．问题重述设计一个程序生成一副总共54张的牌，来给三个玩家发牌，发给每位玩家17张牌，剩下三张作为底牌。

每次发出的牌都不一样，而且按从小到大的顺序显示每个玩家拿到的牌和底牌。

二．算法描述本程序除了运用一些条件语句，判断语句之外，主要运用了两个算法，一个是随机数的生成，一个是冒泡排序法。

随机数的生成的复杂度为O(N)，其中N=54，这是在运行结果最佳的状况下才会出现的，一旦生成的随机数相同的话，通过if语句会重新生成随机数，直到生成不同的随机数。

冒泡排序法的空间复杂度为O(1)，时间复杂度为O(N2)，本程序中的N为54，而且运行了两次冒泡排序法，分别为牌数和花色进行排序，所以空间复杂度为2×O(1)，时间复杂度为2×O(542)。

三．变量说明a[17],b[17],c[17],d[3]为全局变量的数组，分别存放玩家一，二，三的牌，以及三个底牌。

四．函数与思路说明本程序总共有3个子函数，1个主函数，其中3个子函数分别为Xipai()子函数，Paxu()子函数，Fapai()子函数。

Xipai()这个子函数利用了srand(time(0)),rand()来生成随机数1到54。

C语言实现斗地主发牌程序

实验四、斗地主发牌程序的实现一、实验目的1.了解线性表的顺序存储与基本操作；2.了解线性表的链接存储与基本操作；二、实验工具VC6.0三、实验练习和要求3.1实验内容：1）考虑好纸牌的存储结构，定义好纸牌大小的比较规则；2）分别建立顺序线性表和链接线性表，可以进行定位删除，可以进行保序插入，可以进行顺序输出……；3）利用上述线性表类，构造若干个线性表的实例，构造一个含有全部纸牌的线性表，从中随机抽取……随机发给三家（每家17张），并保留底牌3张；4）按大小顺序分别输出各家的牌和底牌。

3.2实验要求：1)利用♣♦♥♠王显示每家发得的牌和底牌(ASCII:\5\4\3\6)；2)每家的牌要求有序排列（数字中3最小，2最大，不同的花色按♣,♦,♥,♠,王渐大处理)；3)所发的牌是随机的；4）顺序线性表和链接线性表都要用到。

3.3实验难点：1）如何存储一张牌；2）如何比较牌的大小（345678910JQKA2）；3）如何实现顺序表与链接表的无差别性？3.4实现提示1）54张牌可以用整数：0--53来表示，也可以用两个独立的整数来表示；2）用利用C语言的RAND()函数来产生随机数；3）牌的大小比较规则，除王比较大外，一般的牌先比较点儿数，再比较花色；4）建议用保序插入，而不要使用最后排序。

3.5注意事项1）顺序表和链接表的操作接口要尽量一致；2）345678910JQKA2中的10占两位？3）大王与小王的特殊处理。

3.6本次实验可以三人构成学习小组，上交一份作业，并给出每一个人贡献分数。

四、实验内容本次实验分别使用顺序表和单链表实现，三人手中的牌都已经按照大小以及花色从小到大排序。

代码如下：➢顺序表实现随机发牌#include<stdio.h>#include<malloc.h>#include <time.h>#include <stdlib.h>#define MaxSize 100typedef int dataType;typedef struct {dataType data[MaxSize];int size ;}SqList;SqList* CreateList(dataType a[],int n){SqList*t=(SqList*)malloc(sizeof(SqList));for(int i=0;i<n;i++)t->data[i]=a[i];t->size=n;return t;}SqList* CreateListemp(){SqList *t =(SqList *)malloc(sizeof(SqList));t->size=0;return t;}void Exchange(SqList *l,int i,int j){int temp;temp=l->data[i];l->data[i]=l->data[j];l->data[j]=temp;}int Min(SqList *l){int min=l->data[0];for(int i=1;i<l->size;i++){if(l->data[i]<min) min=l->data[i];}return min;}void Delete(SqList *l,int k){if (k<1||k>l->size) exit(1);for (int i=k;i<l->size;i++)l->data[i-1] =l->data[i];l->size--;}int Locate(SqList *l,dataType x){for(int i=0;i<l->size;i++)if(l->data[i]==x) return i+1;return 0;}void Print(SqList *l){for (int i=0;i<l->size;i++)printf("%d ",l->data[i]);}SqList* Sort(SqList *pa){SqList *pb=CreateListemp();int M;for(int i=0;i<17;i++){M=Min(pa);pb->data[i]=M;Delete(pa,Locate(pa,M));pb->size++;}return pb;}int main(){int a[54],i,j,N;int one[17];int two[17];int three[17];int cover[3];char *poker[]={"梅花3","方块3","红桃3","黑桃3","梅花4","方块4","红桃4","黑桃4","梅花5","方块5","红桃5","黑桃5","梅花6","方块6","红桃6","黑桃6", "梅花7","方块7","红桃7","黑桃7","梅花8","方块8","红桃8","黑桃8","梅花9", "方块9","红桃9","黑桃9","梅花10","方块10","红桃10","黑桃10","梅花J","方块J", "红桃J","黑桃J","梅花Q","方块Q","红桃Q","黑桃Q","梅花K","方块K","红桃K", "黑桃K","梅花A","方块A","红桃A","黑桃A","梅花2","方块2","红桃2","黑桃2", "小王","大王"};printf("顺序表实现：3个人,每人随机发17张牌,留3张底牌。

斗地主比赛规则

比赛规则：1、发牌一副牌54张，一人17张，留3张做底牌,在确定地主之前玩家不能看底牌.2、洗牌每轮结束均由该轮地主洗牌，由地主的上家（即地主左手方)端牌确认唯一一张地主牌。

首次地主为裁判端牌确认唯一一张地主牌.3、叫牌首先由当轮唯一地主牌获得者叫分，然后按出牌的顺序轮流进行，每人最多只能叫一次。

叫牌时可以叫“1分”，“2分”，“3分”,“不叫”.后叫牌者只能叫比前面玩家高的分或者不叫。

叫牌结束后所叫分值最大的玩家为地主；如果有玩家叫“3分"则立即结束叫牌，该玩家为地主；如果都不叫,则重新发牌。

4、出牌将三张底牌交给地主，并亮出底牌让所有人都能看到。

地主首先出牌，然后按逆时针顺序依次出牌，轮到用户跟牌时，用户可以选择“不出”或出比上一个玩家大的牌。

某一玩家出完牌时结束本局.5、牌型及大小火箭：即双王（大王和小王）,最大的牌，比火箭小,比其他牌大。

炸弹：四张同数值牌（如四个7）,都是炸弹时按牌的分值比大小。

单牌、对牌、三张牌：不分花色，按分值比大小.三带一：数值相同的三张牌+一张单牌或一对牌.例如：333+6或444+99单顺、双顺、三顺:顺牌按最大的一张牌的分值来比大小。

不包括2点和双王。

飞机带翅膀:三顺＋同数量的单牌（或同数量的对牌）.四带二:四张牌＋两手牌。

注意事项：u数值相同的三张牌可以带一张单牌或一对牌u四带二不是炸弹u飞机带翅膀和四带二按其中的三顺和四张部分来比，带的牌不影响大小u参与者可预先在网上进行演练计分规则：一局结束,分数计算：地主得分=2×胜负参数×底分×倍数农民得分=胜负参数×底分×倍数其中,胜负参数：胜利方为1，失败方为-1；底分：初始叫分时的1、2、3分；倍数：2n,其中n为有效炸弹总次数晋级规则：淘汰赛:比赛分为A、B、C、D四个小组，各小组先进行淘汰赛比赛3轮，抽签决定每桌的对手，结束后各桌选手按照积分进行排名，积分最高的选手进入下一轮，若积分相同,则加赛一场,仍相同则抽签决出晋级者。

关于斗地主的玩法

关于斗地主的玩法各种斗地主的玩法非炸弹牌型要牌型和张数相同才能比较大小，点数大的则大。

顺牌按最大的牌点比大小。

带牌牌型中除飞船外，所带牌不影响大小。

炸弹牌型大于非炸弹牌型，炸弹牌型间张数多的大，张数相同时按点数比大小。

天王炸弹最大。

1、CT斗地主CT斗地主是波克城市自创的斗地主，与一副牌相似。

游戏简介该游戏由三人玩一副牌，地主为一方，其余两家为另一方，双方对战，先出完手中牌的一方胜。

《斗地主》游戏截图常见用语解释：发牌：一副牌 54 张，一人 17 张，留 3 张做底牌，在确定地主之前会员不能看底牌。

叫牌：叫牌按出牌的顺序轮流进行。

后叫牌者只能叫比前面会员高的分或者不叫。

叫牌结束后所叫分值最大的会员为地主;如果有会员叫“3 分” 则立即结束叫牌，该会员为地主;如果都不叫，则重新发牌，重新叫牌。

第一个叫牌的会员：第一轮叫牌的会员由系统选定，以后每一轮首先叫牌的会员按出牌顺序轮流担任。

牌型介绍牌型的大小：火箭最大，可以打任意其他的牌。

炸弹比火箭小，比其他牌大。

都是炸弹时按牌的分值比大小。

除火箭、天炸和炸弹外，其他牌必须要牌型相同且总张数相同才能比大小。

单牌按分值比大小，依次是大王 > 小王 >2>A>K>Q>J>10>9>8>7>6>5>4>3 ，不分花色。

对牌、三张牌都按分值比大小。

顺牌按最大的一张牌的分值来比大小。

飞机带翅膀按其中的三顺部分来比，带的牌不影响大小。

四带二按其中4张数值的牌来比，带的牌不影响大小。

积分算法：底分：叫牌的分数单局封顶值：是这一局赢的会员的分值或输的会员的分值的总和不能超过单局封顶所设的数值。

系统得分：每局中由赢的会员所付会员在赢的那局所得到的分值抽走一定比例的分给系统会员掉线：若有会员掉线后由系统代打，并且无论这局结果如何，该会员都要被抽走该局的初始倍数的10倍做为被惩罚的分值。

惩罚的分值不受炸弹或满贯所影响。

基于C语言的斗地主发牌程序的实现

ｆｏｒ（ｉ＝０；ｉ＜Ｎ：ｉ＋＋１
１．２在编写斗地主发牌程序过程中，主要遇到的问题（１）如何实现牌的打乱；（２）如何将牌发给玩家，
一
｛
次性还是一个一个的发等等；（３）如何将按既按照大
｝）
】
既将数组中，每一位的数都与其后面的数进行比较，若比后面的大，则交换数的位置，直到最后，将这组数组按从ｄ，Ｎ大的顺序排序。在本程序中，也运用选择排序，将每位玩家的手牌和底牌都进行排序，不同的是进行了两次排序，分别对牌的大小和花色进行排序。其复杂度为２ｏ（Ｎ，、２），Ｎ＝５４，空间复杂度为２＂１。２＿３变量说明全局变量：程序中定义了多了全局变量，大大简化了程序的复杂程度和繁琐的定义以及函数实参的调用，具体有存放三玩家手牌的数组ｐｌａｙｅｒ［］［］，存放底牌的数组ＬａｓｔＣａｒｄ［】，以及循环计数量ｉ，ｊ，ｋ。２．４函数说明２．４．１ｖｏｉｄｓｈｕｌｅ（ｆ）—— 洗牌函数洗牌函数的思路是先定义数组ｐｏｋｅｒ［］，用来存放５４张扑克牌，然后运用随机数的生成，从１ — ５４中随机抽取一个数，与ｌ交换：从２５４中随机抽取一个数，与２交换 …… 从

斗地主的玩法和规则

斗地主的玩法和规则
斗地主是我国一种最受欢迎的棋牌游戏，其玩法和规则由多种变化：
1、玩家
斗地主需要3名玩家参加，每个玩家分别拥有17张牌。

2、发牌
斗地主使用54张牌，包括3个“2”、4个“A”、5个“K”、6个“Q”、7个“J”以及36张除此之外的牌。

游戏开始时，先将54张牌洗牌，然后从中抽取3张牌留作底牌，剩下的51张牌称为开牌，由一位玩家抓，将开牌中的牌发给三个玩家，分别发17张牌；玩家需从17张牌中以小到大的顺序排列自己的牌，以便于在轮到自己的时候，可以更加方便地出牌；最后把底牌放在桌子上，不再重新整理，表示游戏开始。

3、牌型
放地主牌型分三种：单张、对子和三张，其中三张可分为三张同点数和三带一（即三张同点数+任意一张牌），对子可分为两个同点数的对子和三带二（即三张同点数+两张不同的牌），最大的牌型是四带二（即四张一样的包括任意两张牌），以及炸弹（即四张同点数）。

4、出牌
每局游戏的第一个出牌的人由玩家选择，之后的出牌由上一次出的
牌决定，即按照上一次出牌的大小顺序出牌。

玩家可以出单张，可以出对子，可以出三张，也可以出三带一或三带二，甚至可以出四带二炸弹等，每个玩家都可以充分发挥策略。

5、地主
按照以上规则开始游戏，所有人都出完牌后，发现玩家发出了17张牌，而另外3张牌仍没有任何人抓取，此时，接下来的出牌者就获得了当前局的地主身份，并由地主首先出牌，可以出任意牌型，不受地主上家的出牌约束。

6、计分
游戏结束时，如果地主胜利，那么地主会获得三倍的分数，农民阵营则会获得相应的一半得分；如果农民胜利，地主会获得零分，而农民队伍则会获得一倍的分数。

C语言实现斗地主发牌程序

实验四、斗地主发牌程序的实现一、实验目的1.了解线性表的顺序存储与基本操作；2.了解线性表的链接存储与基本操作；二、实验工具VC6.0三、实验练习和要求3.1实验内容：1）考虑好纸牌的存储结构，定义好纸牌大小的比较规则；2）分别建立顺序线性表和链接线性表，可以进行定位删除，可以进行保序插入，可以进行顺序输出……；3）利用上述线性表类，构造若干个线性表的实例，构造一个含有全部纸牌的线性表，从中随机抽取……随机发给三家（每家17张），并保留底牌3张；4）按大小顺序分别输出各家的牌和底牌。

3.2实验要求：1)利用♣♦♥♠王显示每家发得的牌和底牌(ASCII:\5\4\3\6)；2)每家的牌要求有序排列（数字中3最小，2最大，不同的花色按♣,♦,♥,♠,王渐大处理)；3)所发的牌是随机的；4）顺序线性表和链接线性表都要用到。

3.3实验难点：1）如何存储一张牌；2）如何比较牌的大小（345678910JQKA2）；3）如何实现顺序表与链接表的无差别性？3.4实现提示1）54张牌可以用整数：0--53来表示，也可以用两个独立的整数来表示；2）用利用C语言的RAND()函数来产生随机数；3）牌的大小比较规则，除王比较大外，一般的牌先比较点儿数，再比较花色；4）建议用保序插入，而不要使用最后排序。

3.5注意事项1）顺序表和链接表的操作接口要尽量一致；2）345678910JQKA2中的10占两位？3）大王与小王的特殊处理。

3.6本次实验可以三人构成学习小组，上交一份作业，并给出每一个人贡献分数。

四、实验内容本次实验分别使用顺序表和单链表实现，三人手中的牌都已经按照大小以及花色从小到大排序。

代码如下：➢顺序表实现随机发牌#include<stdio.h>#include<malloc.h>#include <time.h>#include <stdlib.h>#define MaxSize 100typedef int dataType;typedef struct {dataType data[MaxSize];int size ;}SqList;SqList* CreateList(dataType a[],int n){SqList*t=(SqList*)malloc(sizeof(SqList));for(int i=0;i<n;i++)t->data[i]=a[i];t->size=n;return t;}SqList* CreateListemp(){SqList *t =(SqList *)malloc(sizeof(SqList));t->size=0;return t;}void Exchange(SqList *l,int i,int j){int temp;temp=l->data[i];l->data[i]=l->data[j];l->data[j]=temp;}int Min(SqList *l){int min=l->data[0];for(int i=1;i<l->size;i++){if(l->data[i]<min) min=l->data[i];}return min;}void Delete(SqList *l,int k){if (k<1||k>l->size) exit(1);for (int i=k;i<l->size;i++)l->data[i-1] =l->data[i];l->size--;}int Locate(SqList *l,dataType x){for(int i=0;i<l->size;i++)if(l->data[i]==x) return i+1;return 0;}void Print(SqList *l){for (int i=0;i<l->size;i++)printf("%d ",l->data[i]);}SqList* Sort(SqList *pa){SqList *pb=CreateListemp();int M;for(int i=0;i<17;i++){M=Min(pa);pb->data[i]=M;Delete(pa,Locate(pa,M));pb->size++;}return pb;}int main(){int a[54],i,j,N;int one[17];int two[17];int three[17];int cover[3];char *poker[]={"梅花3","方块3","红桃3","黑桃3","梅花4","方块4","红桃4","黑桃4","梅花5","方块5","红桃5","黑桃5","梅花6","方块6","红桃6","黑桃6", "梅花7","方块7","红桃7","黑桃7","梅花8","方块8","红桃8","黑桃8","梅花9", "方块9","红桃9","黑桃9","梅花10","方块10","红桃10","黑桃10","梅花J","方块J", "红桃J","黑桃J","梅花Q","方块Q","红桃Q","黑桃Q","梅花K","方块K","红桃K", "黑桃K","梅花A","方块A","红桃A","黑桃A","梅花2","方块2","红桃2","黑桃2", "小王","大王"};printf("顺序表实现：3个人,每人随机发17张牌,留3张底牌。

欢乐斗地主规则范文

欢乐斗地主规则范文一、基本规则1.一副扑克牌，不包括大小王，共计54张；2.游戏总分为100分，玩家达到100分即为胜利；3.三个玩家分别为地主和两个农民，游戏开始时随机决定谁先做地主；4.游戏采用轮流叫地主的方式确定地主和底牌的归属权；5.所有玩家初始得分为0，每局游戏结束后，根据玩家出单牌、对牌、三张、炸弹等情况进行计分。

二、游戏流程1.发牌：首先将54张扑克牌洗混后，按照顺时针方向轮流发牌，每人17张牌，剩余3张作为底牌；2.叫地主：游戏开始后，由地主下家优先叫地主，每个玩家有且只有一次叫地主的机会。

玩家可选择叫分的倍数，起始倍数为1，递增至6倍。

若玩家叫地主，则底分翻倍；若放弃叫地主，则下家继续叫地主，直至有玩家叫地主为止。

叫地主者即为地主，其余两位玩家为农民；3.底牌交换：地主获得底牌后，可以选择将底牌中的三张牌与手中的三张牌交换，实际上地主牌数为20张，农民牌数为17张；4.出牌：地主首先出手，按照先出牌的玩家的规则进行比较。

玩家需要按照牌型规则，出比较大的牌。

规则如下：a)单牌：任意一张牌；b)对牌：两张点数相同的牌；c)三张：三张点数相同的牌；d)炸弹：四张点数相同的牌；e)顺子：五张或更多点数连续的牌；f)连对：两对或更多对子，且点数连续；g)三带一：三张点数相同的牌带一张单牌；h)三带二：三张点数相同的牌带一对牌；j)飞机带翅膀：两个或更多个连续的三张，每个三张可以带一张单牌或一对牌；k)王炸：即大王和小王的组合；5.其他规则：a)玩家必须出牌，如果没有比上家牌更大的牌，则必须选择过牌；b)出炸弹可以随意打破规则，炸弹可以比较大小，大王和小王可以与任何牌组合成炸弹；c)当其中一玩家打完所有手牌后，游戏结束，进行结算。

三、计分规则1.地主获胜：若地主先出完手牌，或地主剩余手牌牌数少于农民，则地主获胜，每名农民要减去一定分数；2.农民获胜：若两名农民先出完手牌，或地主剩余手牌数少于农民，则农民获胜，每名农民会获得一定分数；3.结算：根据游戏结果，根据不同的情况进行积分，胜利方得分，失败方扣分，计分方式可根据实际情况约定。

单机版斗地主的游戏算法的设计毕业设计论文

摘要随着科技的进步，计算机已经普及每个家庭，而计算机游戏也随之越来越多，越来越丰富。

网络游戏、单机游戏等休闲游戏让众多人喜欢，而斗地主也受广大群众的追捧。

本设计以一副牌规则为准，将整个游戏按照发牌,叫牌，拆牌，以及出牌的流程划分为4个部分，开始时由系统调用发牌函数每人随机分到17张牌，留存3张底牌，然后电脑AI根据自己手上牌值与牌型结合给定权值决定是否叫三张底牌当地主。

一旦叫牌成功，剩下两玩家就是农民，联合“斗地主”。

双方以是否出完牌来决定胜负。

如果地主的20张牌都出完了，则地主一方胜；如果两个农民中任何一人手中的17张牌出完了，则农民一方胜出。

本论文主要讲述了单机版斗地主的游戏算法的设计，以Visual C++语言编译的一个应用程序。

使用者可以简单方便的实现斗地主游戏。

本程序界面友好，操作简单，比较实用。

本程序在详细设计时不断地修正和完善，经过测试阶段反复调试和验证，最终形成达到设计要求的可行系统。

关键词: 斗地主;纸牌; Visual C++;游戏核心算法AbstractWith the progress of science and technology, computers have universal every family, and with more and more computer games, increasingly rich.The network game, LAN game and other casual games for many people like it, but Landlord also affected by the broad masses in both hands.This design will be subject to rules of a deck of cards, the entire game in accordance with the licensing, call, cards, as well as the process is divided into four parts.Licensing function is called by the system at the beginning, then 17 cards are randomly assigned to each person and three cards are also retained. After that, the computer AI decides whether to call cards based on it's own cards value and the cards type which all have a particular weight.Once the call is successful, the remaining two players is farmers, jointing "Landlords". Whether the two sides finish cards determine the winner. If the landlord's 20 cards are finished, the landlord side win; If any one of the two farmers finishes 17 cards , the farmers win.This paper tells the stand-alone Landlord game algorithm is designed to Visual c + + language compiled an application. Users can simple to realize Fight the Landlord game. This procedure friendly interface, the operation is simple, is more practical.This procedure in the detailed design constantly correction and perfect when, after testing phase repeated commissioning and validation, and finally form the feasible system to meet the design requirements.Key Words: Fight the landlord; Cards; Visual C++; Game core algorithm目录1 绪论1.1 课题背景 (1)1.2 研究现状 (1)1.3 研究项目及意义 (1)1.4 本文的结构安排 (1)1.5 系统开发工具及其介绍 (2)1.5.1 开发工具的选择 (2)1.6 Visual C++编程特点 (3)1.6.1 C++语言的发展 (3)1.6.2 Visual C++ 6.0简介 (3)1.6.3 Visual C++ 6.0的开发环境 (4)2 斗地主基本知识 (4)2.1 斗地主规则 (4)2.2游戏流程框架 (5)3 主要模块 (6)3.1发牌 (6)3.1.1 第一发牌方案 (6)3.1.2第二发牌方案 (7)3.1.3 发牌算法的代码实现 (8)3.2 叫牌 (10)3.2.1 叫牌判断 (10)3.2.2 牌型估值 (10)3.3 拆牌 (14)3.3.1拆牌原因 (14)3.3.2寻找拆牌方案 (15)3.3.3 拆牌实例 (22)3.4 出牌 (22)3.4.1 出牌方法产生 (22)3.4.2 产生方法 (23)3.4.3效率问题 (24)3.4.4逐个产生和全部产生 (24)3.4.5内存使用 (25)4 结论及展望 (25)致谢 (27)参考文献 (28)1 绪论1.1 课题背景“斗地主”起源于湖北，据传是一位叫吴修全的年轻人，根据当地流行的扑克玩法“跑的快”改编的。

扑克牌斗地主的玩法

工具/原料
普通扑克牌
方法/步骤
1.斗地主技巧初级，就是我们在某些情况下作出的一些反应，可能和高级、超级相差甚远。比如说初级水平的人，有双王时必定叫牌；除非自己的对家剩5张以下时，才会想到协助对方跑光。否则，最关心的是怎么让自己的牌先走掉，当地主是自己下家时，不会顶牌栏住下家。
2.斗地主技巧而对中级来说，方法就会有所改变了。能记住哪些牌已经出过，哪些牌还没有出过；认为是否叫牌应该根据手上的牌形和大牌数量来判断，并且懂得怎么防止地主走小牌。
对牌、三张牌都按分值比大小。
顺牌按最大的一张牌的分值来比大小。
飞机带翅膀和四带二按其中的三顺和四张部分来比，带的牌不影响大小。
7、胜负判定
任意一家出完牌后结束游戏，若是地主先出完牌则地主胜，否则另外两家胜。
8、积分
底分：叫牌的分数
倍数：初始为1，每出一个炸弹或火箭翻一倍。（火箭和炸弹留在手上没出的不算）
5.
炸弹：四张同数值牌（如四个7）。
单牌：单个牌（如红桃5）。
对牌：数值相同的两张牌（如梅花4+方块4）。
三张牌：数值相同的三张牌（如三个J）。
三带一：数值相同的三张牌+一张单牌或一对牌。例如：333+6或444+99
单顺：五张或更多的连续单牌（如：45678或78910JQK）。不包括2点和双王。
飞机带翅膀：三顺＋同数量的单牌（或同数量的对牌）。
3.斗地主技巧最为高级水平的牌手，就更加的精明了。打完三局，能分析出每个人的打牌习惯，进而会根据别人的打牌特点而改变自己的出牌，从而达到配合对家或打击敌人；明白在打牌的时候34567。
4.斗地主技巧最后就是超级水平的牌手了，这类牌手，能够将每一张牌都派上用场，并且心理有一个成熟的计划。在实战当中，能记得绝大多数的牌，知道3个人手上，总共还剩哪些牌。而且这些牌大体上是怎么分布的，并且都是凭自己的脑子来记得。

C#斗地主算法

斗地主出牌算法根据斗地主出牌规则.对玩家出的牌进行检验.判断是否符合出牌规则.(关于斗地主的出牌规则网上有很多)思路:将玩家的牌按升序排序.然后将牌进行拆分,分存在4个数组中.拆分规则如下:假设有牌:333\444\555\789则拆分后数组中的数据如下arr[0]:345789arr[1]:345arr[2]:345arr[3]:null可以看出拆分规则是:如果遇到相同数字的牌则存到下一个数组的末尾.拆分完后可以根据各数组的存储情况判定玩家出牌的类型,上面例子arr[3]为空.可以排除掉4带1(2).炸弹.的情况根据arr[2]为顺子且个数大于1,且arr[2]中存放的牌的张数乘以3刚好等于arr[0]的张数+arr[1]的张数.则可以判定是三带一的飞机.其他类型的牌也有相似的规律.以下是该算法的核心源代码.本算法用C#编写.using System;using System.Collections.Generic;using System.Text;namespace LordLibrary{/**以下程序版权由林奕霖所有,有兴趣的朋友可以用来交流和探讨.但请别用于商业用途.否则后果自负.*您可以自由拷贝修改此源代码,但必须保留此注释.*/public class CheckType{private static int[][] DiffRow(int[] nums){int[][] list = new int[4][];for (int i = 0; i < list.Length; i++){list = new int[20];}int[] rowIndex = new int[4];int columIndex = 0;for (int i = 0; i < nums.Length; i++){if (i + 1 < nums.Length){if (nums != 0){list[columIndex][rowIndex[columIndex]] = nums;rowIndex[columIndex]++;}if (nums == nums[i + 1]){columIndex++;}else{columIndex = 0;}}else if (nums != 0)list[columIndex][rowIndex[columIndex]] = nums;}return list;}private static int checkListCount(int[][] list, int rowIndex, int compStart, int rowMaxCount) {/* LIST 代表单顺.*DOUB 代表双顺.*FEI0 代表三顺.*FEI1 代表三带一的飞机*FEI2 代表三带二的飞机*FOR1 代表四带1*FOR2 代表四带2*ROCK 代表大小王*/int listCount = 1;for (int i = compStart; i < rowMaxCount - 1; i++){if (list[rowIndex] + 1 == list[rowIndex][i + 1])listCount++;elselistCount = 1;}return listCount;}public static string getCardType(int[] nums){int[][] list = DiffRow(nums);int[] counts = new int[4];for (int k = 0; k < 4; k++){counts[k] = Array.IndexOf(list[k], 0);}int MaxV alue = 0;int listCount = 0;string type = string.Empty;//当第4行牌的数量为1的时候#regionif (counts[3] == 1){int index = Array.IndexOf(list[2], list[3][0]);switch (counts[2]){case 1:MaxV alue = list[3][0];if (counts[0] == 1){type = "BOMB:4:" + MaxV alue;}else if (counts[0] + counts[1] == 4){type = "FOR1:6:" + MaxV alue;}else if (counts[0] == counts[1] && counts[0] == 3){type = "FOR2:8:" + MaxV alue;}break;case 2:if (list[2][0] + 1 == list[2][1] && counts[1] == counts[2] && counts[0] == 3){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + counts[2] + ":" + MaxV alue;} break;case 3:if (checkListCount(list, 2, 0, counts[2]) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + counts[2] + ":" + MaxV alue;}else if (Array.IndexOf(list[2], list[3][0]) == 0 && counts[0] == counts[2]){if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1){MaxV alue = list[2][counts[2] - 1];type = "FEI2:" + listCount + ":" + MaxV alue;}}else if (Array.IndexOf(list[2], list[3][0]) == counts[2] - 1 && counts[0] == counts[2]){if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1){MaxV alue = list[2][counts[2] - 2];type = "FEI2:" + listCount + ":" + MaxV alue;}}break;case 4:if (index == 0 && counts[0] == counts[1] && counts[0] == 5){if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1){MaxV alue = list[2][counts[2] - 1];type = "FEI2:" + listCount + ":" + MaxV alue;}}else if (index == counts[2] - 1 && counts[0] == counts[1] && counts[0] == 5){if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1){MaxV alue = list[2][counts[2] - 2];type = "FEI2:" + listCount + ":" + MaxV alue;}}else if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}break;case 5:if (index == 0){if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if (listCount == counts[2] - 1 && counts[0] == counts[1]){if (counts[0] + 1 == 2 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 1];type = "FEI2:" + listCount + ":" + MaxV alue;}else if (2 * (counts[0] + 1) == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}}}else if (index == counts[2] - 1){if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] == counts[1]){if (counts[0] + 1 == 2 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 2];type = "FEI2:" + listCount + ":" + MaxV alue;}else if (2 * (counts[0] + 1) == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 2];type = "FEI1:" + listCount + ":" + MaxV alue;}}}else{if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}}break;case 6:if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if (index == 0 && listCount == counts[2] - 1 && counts[0] + counts[1] + 2 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if (index == counts[2] - 1 && (listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] + counts[1] + 2 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 2];type = "FEI1:" + listCount + ":" + MaxV alue;}break;}}#endregion//当第4行牌的数量为2的时候#regionif (counts[3] == 2){switch (counts[2]){default:if (counts[2] >= 2 && counts[2] < 6){if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}}break;case 6:int firstIndex = Array.IndexOf(list[2], list[3][0]);int secIndex = Array.IndexOf(list[2], list[3][1]);if (secIndex == 1){if ((listCount = checkListCount(list, 2, 2, counts[2])) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2)){MaxV alue = list[2][counts[2] - 1];type = "FEI2:" + listCount + ":" + MaxV alue;}}else if (secIndex == counts[2] - 1){if (firstIndex == 0){if ((listCount = checkListCount(list, 2, 1, counts[2] - 1)) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2)){MaxV alue = list[2][counts[2] - 2];type = "FEI2:" + listCount + ":" + MaxV alue;}}else if (firstIndex == secIndex - 1){if ((listCount = checkListCount(list, 2, 0, counts[2] - 2)) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2)){MaxV alue = list[2][counts[2] - 3];type = "FEI2:" + listCount + ":" + MaxV alue;}}}if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1 && 2 * counts[0] + 3 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && 2 * counts[0] + 3 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 2];type = "FEI1:" + listCount + ":" + MaxV alue;}break;}}#endregion//当第4行牌的数量大于2的时候#regionif (counts[3] > 2){if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}}#endregion//当第4行牌的数量为0,第三行牌的数量大于0#regionif (counts[3] == 0 && counts[2] > 0){if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2]){if (counts[0] == counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI0:" + listCount + ":" + MaxV alue;}else if (counts[0] + counts[1] == 3 * counts[2]){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if (counts[0] + counts[1] == 4 * counts[2] && counts[0] == counts[1]){MaxV alue = list[2][counts[2] - 1];type = "FEI2:" + listCount + ":" + MaxV alue;}}if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1 && counts[0] + counts[1] + 1 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 1];type = "FEI1:" + listCount + ":" + MaxV alue;}else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] + counts[1] + 1 == 3 * (counts[2] - 1)){MaxV alue = list[2][counts[2] - 2];type = "FEI1:" + listCount + ":" + MaxV alue;}}#endregion//当第3行牌的数量为0，第二行牌的数量大于0#regionif (counts[2] == 0 && counts[1] > 0){if (counts[0] == 1){MaxV alue = list[1][counts[1] - 1];listCount = counts[1];type = "DOUB:" + listCount + ":" + MaxV alue;}else{if (counts[1] > 2 && counts[0] == counts[1] && (listCount = checkListCount(list, 1, 0, counts[1])) == counts[1]){MaxV alue = list[1][counts[1] - 1];type = "DOUB:" + listCount + ":" + MaxV alue;}}}#endregion//当第2行牌的数量为0#regionif (counts[1] == 0){if (counts[0] == 1){MaxV alue = list[0][counts[0] - 1];listCount = counts[0];type = "LIST:" + listCount + ":" + MaxV alue;}else if (counts[0] == 2 && list[0][0] == 16 && list[0][1] == 17){type = "ROCK:2:17";}else if (counts[0] >= 5 && (listCount = checkListCount(list, 0, 0, counts[0])) == counts[0]){MaxV alue = list[0][counts[0] - 1];listCount = counts[0];type = "LIST:" + listCount + ":" + MaxV alue;}}#endregionString[] cmd= type.Split(new char[]{':'});int big = Array.IndexOf(nums, 16);int small = Array.IndexOf(nums, 17);if (cmd.Length > 0 && cmd[0]!=string.Empty){if ((cmd[0]=="LIST" || cmd[0]=="DOUB" || cmd[0]=="FEI0" || cmd[0]=="FEI1"|| cmd[0]=="FEI2")&& (int.Parse(cmd[1]))>1){type = int.Parse(cmd[2]) > 14 ? string.Empty : type;}else if (cmd[0] == "FOR1" || cmd[0] == "FOR2"){type = (big >0 && small>0) ? string.Empty : type;}}return type;}}}。

斗地主比赛规则

斗地主晋级赛—比赛规则简介：1、比赛每组三人参加，玩一副扑克牌，叫牌的一家称为“地主”，单独为一方，其余两家称为“贫农”，2个贫农为另一方；双方对战，先出完手中牌的一方获胜，其余一方为负；2、任意参赛者出完牌后结束比赛，即为1局；一、发牌规则一副扑克牌 54 张，一人 17 张，留 3 张做底牌；按叠牌顺序，由裁判员按照1次2张、5次3张的方式依次发牌；在确定地主之前参赛者均不能看到底牌；确定地主后，由裁判公示底牌后再交予叫牌的一人，该人即为“地主”。

其余未叫牌的两人即为“贫农”。

二、叫牌规则1、普通叫牌程序：扑克牌由裁判随机切牌，并在上下10张中间随机翻出明牌；由分配到明牌的人优先叫牌；分配到明牌的人放弃后叫牌后，按逆时针顺序轮流至下一人拥有叫牌权利；如该人仍放弃叫牌，剩下的1人则必须叫牌。

2）必须叫牌的情形：按普通叫牌程序规定，拥有叫牌权利者所分配扑克牌出现以下情形，则必须叫牌：分配到双王（大王和小王）构成的火箭的一方，必须叫牌；分配到四个2点构成的炸弹的一方，必须叫牌；分配到大王（或者小王）加上两个2点的一方，必须叫牌；分配到大王（或者小王）加上2个炸弹的一方，必须叫牌；分配到两个2点加上2个炸弹的一方，必须叫牌；分配到3个炸弹的一方，必须叫牌；三、出牌规则裁判亮出底牌让所有参赛者都看到后，将三张底牌交给叫牌的地主；地主首先出牌，然后按逆时针顺序依次出牌，轮到下一家跟牌时，可以选择“不出”或出比上一家大的牌；剩下最后一组牌可以一次出完的，必须一次出完；任何一家出完所有牌时结束本局；出牌时，手中拿出的扑克牌高于桌面挡板即为牌已出，不得收回；所出扑克牌必须放置在桌面的三角挡板中间，由裁判按照出牌顺序将扑克牌翻转（背面向上）收拢，任何一方不得翻看已出扑克牌；每轮（同一牌型）出牌时，上家出牌放置在桌面的三角挡板中间之后，应轮流出牌的下一家在30秒内未出牌，视为放弃该轮出牌。

四、牌型规则火箭：即双王（大王和小王），最大的牌。