C语言实战之纸牌游戏

256 阅读 0 评论 169 点赞

我是靠谱客的博主乐观音响，这篇文章主要介绍C语言实战之纸牌游戏，现在分享给大家，希望可以做个参考。

1. 基本要求

一副没有花牌(J、Q、K、A、大小王)的扑克牌，两个人进行纸牌游戏，其中一个人为用户，另一个人为计算机;
每轮每人各发5张牌，各自以这5张牌建立二叉排序树；
由用户先出，轮流出牌，每次只能出一张并且要比别人出的大，如：用户出3，计算机则要出比3大的牌，没有则选择不出；
最先出完的人获胜。

2. 运行界面

1. 首页面

2. 游戏说明

3. 开始游戏

4. 开始出牌

5. 游戏结束

3. 代码解释

复制代码

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<time.h>

int card[5][2];	 // 分别标记玩家和用户已经出过的牌 
int playercard[5];	 // 玩家的手牌 
int computercard[5]; // 电脑的手牌

char bhuase[5];
char chuase[5];

typedef struct node
{
	int data;
	struct node *LChild;
	struct node *RChild;
}node;

typedef struct tree
{
	int data;
	struct node *LChild;
	struct node *RChild;
}tree;

// 游戏说明
void PlayingCardsyxsm()
{
	printf(" 每轮每人各发5张牌，各自以五张牌建立二叉树，由用户先出，轮流出牌，n");
	printf(" 每次只能出一张并且要比别人出的大，n");
	printf(" 如：用户出3，计算机则要算出比3大的牌，没有则选择不出；n");
	printf(" 最先出完的人获胜。n");
}

// 发牌
void PlayingCardsfp()	 
{
	int player;
	int computer;
	// 玩家和电脑各发五张牌 
	for(int i = 0; i < 5; i ++ ){
		player = rand() % 9 + 2;
		printf("玩家发到的牌：%d n", player); 
		playercard[i] = player;
		computer = rand() % 9 + 2;
		printf("电脑发到的牌：%d n", computer); 
		computercard[i] = computer;
	}
}

// 出牌 
void PlayingCardscp()
{
	int player = 0;	// 玩家当前回合出的牌 
	int computer = 0;	// 电脑当前回合出的牌 
	int playercount = 0;	// 玩家的出牌数 
	int computercount = 0;	// 电脑的出牌数 
	bool flag = false; 
	// 当每次都出现最大值时，游戏同样最多进行5回合 
	for(int m = 0; m < 5; m ++ )
	{
		// 在双方都有牌出的时候，一共最多进行5回合出牌 
		for(int k = 0; k < 5; k ++ )
		{
			for(int j = 0; j < 5; j ++ )
			{
				// 确定当前牌可以出，大于对方的出牌，且自己没有出过这张牌 
				if(playercard[j] > computer && card[j][0] == 0)
				{
					printf("玩家出牌%c%dn", bhuase[j],playercard[j]);
					playercount ++ ;	 // 玩家出牌数+1 
					// 标记玩家已经出过这张牌了 
					card[j][0] = 1;
					player = playercard[j]; 
					Sleep(800);		// 在头函数#include <windows.h>中，起到休眠程序的作用 
					break;
				}
			}
			
			// 若果玩家已经出完5张牌，则玩家获胜，退出循环 
			if(playercount == 5)
			{
				printf("玩家赢了！"); 
				flag = true;
				break;
			}

for(int j = 0; j < 5; j ++ )
			{
				// 确定当前牌可以出，大于对方的出牌，且自己没有出过这张牌 
				if(computercard[j] > player && card[j][1] == 0)
				{
					printf("电脑出牌%c%dn", chuase[j],computercard[j]);
					computercount ++ ;  // 电脑出牌数+1 
					// 标记电脑已经出过这张牌了 
					card[j][1] = 1;
					computer = computercard[j];
					Sleep(800);
					break;
				}
			}
			
			// 若果电脑已经出完5张牌，则电脑获胜，退出循环 
			if(computercount == 5)
			{
				printf("电脑赢了！"); 
				flag = true;
				break;
			}
		}
		
		// 如果玩家的牌大于电脑的最大牌后，将电脑当前回合的牌值重置为0，继续进行下一回合 
		if(player > computer) computer = 0;
		// 如果电脑的牌大于玩家的最大牌后，将玩家当前回合的牌值重置为0，继续进行下一回合 
		if(computer > player) player = 0;
		
		if(flag) break;
		
	}
}

// 发完牌后玩家的手牌 
void PlayingCardsxswj()
{
	printf("玩家n");
	printf("   %d   %d   %d   %d   %dn", playercard[0], playercard[1], playercard[2], playercard[3], playercard[4], playercard[5]);
}

// 发完牌后电脑的手牌 
void PlayingCardsxsdn()
{
	printf("电脑n");
	printf("   %d   %d   %d   %d   %dn", computercard[0], computercard[1], computercard[2], computercard[3], computercard[4], computercard[5]);
}

// 初始化树的头结点为空 
void treechushihua(node *t)
{
	t = NULL;
}

// 建立平衡二叉树 
node *treecharu(node *t, int key)
{
	// 如果头结点为空，就将当前节点设置为根节点 
	if(t == NULL)
	{
		node *p;
		p = (node*)malloc(sizeof(node));
		p->data = key;
		p->LChild = NULL;
		p->RChild = NULL;
		t = p;
	}
	// 如果头结点不为空，则进行平衡二叉树的插入操作 
	else
	{
		// 插入结点的值小于根节点，则插入左子树 
		if(key < t->data)
			t->LChild = treecharu(t->LChild, key);
		// 插入结点的值大于等于根节点，则插入右子树 
		else
			t->RChild = treecharu(t->RChild, key);
	}
	return t;
}

// 将玩家手牌存储到平衡二叉树中 
node *jianlib(node *t)  
{
	int i, key;
	for(i = 0; i < 5; i ++ )
	{
		key = playercard[i];
		t = treecharu(t, key);
	}
	return t;
}

// 将电脑手牌存储到平衡二叉树中 
node *jianlic(node *t)  
{
	int i, key;
	for(i = 0; i < 5; i ++ )
	{
		key = computercard[i];
		t = treecharu(t, key);
	}
	return t;
}

// 顺序输出玩家或电脑手牌 
void treepaixu1(node *t)  
{
	if(t != NULL)
	{
		treepaixu1(t->LChild);
		printf("%d ", t->data);
		treepaixu1(t->RChild);
	}
}

// 先序遍历玩家平衡二叉树 
void treepaixu2(node *t, int *p)  
{
	if(t == NULL) return;
	else
	{
		// 先序遍历，将玩家手牌有序化 
		treepaixu2(t->LChild,  p);
		playercard[(*p) ++ ] = t->data;
		treepaixu2(t->RChild, p);
	}
}

// 先序遍历电脑平衡二叉树 
void treepaixu3(node *t, int *p)  
{
	if(t == NULL) return;
	else
	{
		// 先序遍历，将电脑手牌有序化 
		treepaixu3(t->LChild, p);
		computercard[(*p) ++ ] = t->data;
		treepaixu3(t->RChild, p);
	}
}

// 主函数 
int main()
{
	int k = 0;
	// 随机函数，通过时间种子来获取随机数种子，获得随机数 
	srand((unsigned)time(NULL));
	int n = 0;
	// 选择菜单 
	while(k != -1)
	{
		puts("");
		puts("");
		puts(""); 
		printf("ttt ****纸牌游戏****n");
		printf("ttt****1.游戏说明****n");
		printf("ttt****2.开始游戏****n");
		printf("ttt****3.开始出牌****n");
		printf("ttt****4.游戏结束****n");
		printf("ttt******************n");
		puts("");
		printf("tt**********************************n");
		printf("tt**********************************n");
		puts("");
		printf("ttt请输入（1、2、3、4）：n");
		scanf("%d", &k);
		switch(k){
			// 游戏说明 
			case 1: PlayingCardsyxsm(); break;
			// 发牌阶段 
			case 2:{
				// 发牌 
		  		PlayingCardsfp();
		  		
		  		// 建立玩家二叉树 
		  		node *t1 = NULL;
				t1 = jianlib(t1);
				printf("玩家手牌为："); 
		  		treepaixu1(t1);
		  		
		  		// 建立电脑二叉树 
		  		node *t2 = NULL;
				t2 = jianlic(t2);
				puts("");
				printf("电脑手牌为："); 
				treepaixu1(t2);
				
				// 玩家手牌有序化 
		  		n = 0;
		  		treepaixu2(t1, &n);
		  		
		  		// 电脑手牌有序化 
				n = 0;
		  		treepaixu3(t2, &n);
		  		
		  		puts("");
		  		// 输出玩家和电脑的手牌 
		  		PlayingCardsxswj();
		  		PlayingCardsxsdn();
		 		break;
	  		}
	  		// 出牌阶段 
			case 3:{
				PlayingCardscp();
				break;
	 		}
	 		// 退出游戏  
			case 4:k=-1; break;
		}
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<time.h>

int card[5][2];	 // 分别标记玩家和用户已经出过的牌 
int playercard[5];	 // 玩家的手牌 
int computercard[5]; // 电脑的手牌 

char bhuase[5];
char chuase[5];

typedef struct node
{
	int data;
	struct node *LChild;
	struct node *RChild;
}node;

typedef struct tree
{
	int data;
	struct node *LChild;
	struct node *RChild;
}tree;

// 游戏说明
void PlayingCardsyxsm()
{
	printf(" 每轮每人各发5张牌，各自以五张牌建立二叉树，由用户先出，轮流出牌，n");
	printf(" 每次只能出一张并且要比别人出的大，n");
	printf(" 如：用户出3，计算机则要算出比3大的牌，没有则选择不出；n");
	printf(" 最先出完的人获胜。n");
}

// 发牌
void PlayingCardsfp()	 
{
	int player;
	int computer;
	// 玩家和电脑各发五张牌 
	for(int i = 0; i < 5; i ++ ){
		player = rand() % 9 + 2;
		printf("玩家发到的牌：%d n", player); 
		playercard[i] = player;
		computer = rand() % 9 + 2;
		printf("电脑发到的牌：%d n", computer); 
		computercard[i] = computer;
	}
}

// 出牌 
void PlayingCardscp()
{
	int player = 0;	// 玩家当前回合出的牌 
	int computer = 0;	// 电脑当前回合出的牌 
	int playercount = 0;	// 玩家的出牌数 
	int computercount = 0;	// 电脑的出牌数 
	bool flag = false; 
	// 当每次都出现最大值时，游戏同样最多进行5回合 
	for(int m = 0; m < 5; m ++ )
	{
		// 在双方都有牌出的时候，一共最多进行5回合出牌 
		for(int k = 0; k < 5; k ++ )
		{
			for(int j = 0; j < 5; j ++ )
			{
				// 确定当前牌可以出，大于对方的出牌，且自己没有出过这张牌 
				if(playercard[j] > computer && card[j][0] == 0)
				{
					printf("玩家出牌%c%dn", bhuase[j],playercard[j]);
					playercount ++ ;	 // 玩家出牌数+1 
					// 标记玩家已经出过这张牌了 
					card[j][0] = 1;
					player = playercard[j]; 
					Sleep(800);		// 在头函数#include <windows.h>中，起到休眠程序的作用 
					break;
				}
			}
			
			// 若果玩家已经出完5张牌，则玩家获胜，退出循环 
			if(playercount == 5)
			{
				printf("玩家赢了！"); 
				flag = true;
				break;
			}

			for(int j = 0; j < 5; j ++ )
			{
				// 确定当前牌可以出，大于对方的出牌，且自己没有出过这张牌 
				if(computercard[j] > player && card[j][1] == 0)
				{
					printf("电脑出牌%c%dn", chuase[j],computercard[j]);
					computercount ++ ;  // 电脑出牌数+1 
					// 标记电脑已经出过这张牌了 
					card[j][1] = 1;
					computer = computercard[j];
					Sleep(800);
					break;
				}
			}
			
			// 若果电脑已经出完5张牌，则电脑获胜，退出循环 
			if(computercount == 5)
			{
				printf("电脑赢了！"); 
				flag = true;
				break;
			}
		}
		
		// 如果玩家的牌大于电脑的最大牌后，将电脑当前回合的牌值重置为0，继续进行下一回合 
		if(player > computer) computer = 0;
		// 如果电脑的牌大于玩家的最大牌后，将玩家当前回合的牌值重置为0，继续进行下一回合 
		if(computer > player) player = 0;
		
		if(flag) break;
		
	}
}

// 发完牌后玩家的手牌 
void PlayingCardsxswj()
{
	printf("玩家n");
	printf("   %d   %d   %d   %d   %dn", playercard[0], playercard[1], playercard[2], playercard[3], playercard[4], playercard[5]);
}

// 发完牌后电脑的手牌 
void PlayingCardsxsdn()
{
	printf("电脑n");
	printf("   %d   %d   %d   %d   %dn", computercard[0], computercard[1], computercard[2], computercard[3], computercard[4], computercard[5]);
}

// 初始化树的头结点为空 
void treechushihua(node *t)
{
	t = NULL;
} 

// 建立平衡二叉树 
node *treecharu(node *t, int key)
{
	// 如果头结点为空，就将当前节点设置为根节点 
	if(t == NULL)
	{
		node *p;
		p = (node*)malloc(sizeof(node));
		p->data = key;
		p->LChild = NULL;
		p->RChild = NULL;
		t = p;
	}
	// 如果头结点不为空，则进行平衡二叉树的插入操作 
	else
	{
		// 插入结点的值小于根节点，则插入左子树 
		if(key < t->data)
			t->LChild = treecharu(t->LChild, key);
		// 插入结点的值大于等于根节点，则插入右子树 
		else
			t->RChild = treecharu(t->RChild, key);
	}
	return t;
}

// 将玩家手牌存储到平衡二叉树中 
node *jianlib(node *t)  
{
	int i, key;
	for(i = 0; i < 5; i ++ )
	{
		key = playercard[i];
		t = treecharu(t, key);
	}
	return t;
} 

// 将电脑手牌存储到平衡二叉树中 
node *jianlic(node *t)  
{
	int i, key;
	for(i = 0; i < 5; i ++ )
	{
		key = computercard[i];
		t = treecharu(t, key);
	}
	return t;
} 

// 顺序输出玩家或电脑手牌 
void treepaixu1(node *t)  
{
	if(t != NULL)
	{
		treepaixu1(t->LChild);
		printf("%d ", t->data);
		treepaixu1(t->RChild);
	}
} 

// 先序遍历玩家平衡二叉树 
void treepaixu2(node *t, int *p)  
{
	if(t == NULL) return;
	else
	{
		// 先序遍历，将玩家手牌有序化 
		treepaixu2(t->LChild,  p);
		playercard[(*p) ++ ] = t->data;
		treepaixu2(t->RChild, p);
	}
}

// 先序遍历电脑平衡二叉树 
void treepaixu3(node *t, int *p)  
{
	if(t == NULL) return;
	else
	{
		// 先序遍历，将电脑手牌有序化 
		treepaixu3(t->LChild, p);
		computercard[(*p) ++ ] = t->data;
		treepaixu3(t->RChild, p);
	}
}  

// 主函数 
int main()
{
	int k = 0;
	// 随机函数，通过时间种子来获取随机数种子，获得随机数 
	srand((unsigned)time(NULL));
	int n = 0;
	// 选择菜单 
	while(k != -1)
	{
		puts("");
		puts("");
		puts(""); 
		printf("ttt ****纸牌游戏****n");
		printf("ttt****1.游戏说明****n");
		printf("ttt****2.开始游戏****n");
		printf("ttt****3.开始出牌****n");
		printf("ttt****4.游戏结束****n");
		printf("ttt******************n");
		puts("");
		printf("tt**********************************n");
		printf("tt**********************************n");
		puts("");
		printf("ttt请输入（1、2、3、4）：n");
		scanf("%d", &k);
		switch(k){
			// 游戏说明 
			case 1: PlayingCardsyxsm(); break;
			// 发牌阶段 
			case 2:{
				// 发牌 
		  		PlayingCardsfp();
		  		
		  		// 建立玩家二叉树 
		  		node *t1 = NULL;
				t1 = jianlib(t1);
				printf("玩家手牌为："); 
		  		treepaixu1(t1);
		  		
		  		// 建立电脑二叉树 
		  		node *t2 = NULL;
				t2 = jianlic(t2);
				puts("");
				printf("电脑手牌为："); 
				treepaixu1(t2);
				
				// 玩家手牌有序化 
		  		n = 0;
		  		treepaixu2(t1, &n);
		  		
		  		// 电脑手牌有序化 
				n = 0;
		  		treepaixu3(t2, &n);
		  		
		  		puts("");
		  		// 输出玩家和电脑的手牌 
		  		PlayingCardsxswj();
		  		PlayingCardsxsdn();
		 		break;
	  		}
	  		// 出牌阶段 
			case 3:{
				PlayingCardscp();
				break;
	 		}
	 		// 退出游戏  
			case 4:k=-1; break;
		}
	}
	return 0;
}