1. 基本要求

1. 一副沒有花牌(J、Q、K、A、大小王)的撲克牌，兩個人進行紙牌游戲，其中一個人為用戶，另一個人為計算機;
2. 每輪每人各發5張牌，各自以這5張牌建立二叉排序樹；
3. 由用戶先出，輪流出牌，每次只能出一張并且要比別人出的大，如：用戶出3，計算機則要出比3大的牌，沒有則選擇不出；
4. 最先出完的人獲勝，

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%d\n", 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%d\n", 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   %d\n", playercard[0], playercard[1], playercard[2], playercard[3], playercard[4], playercard[5]);
}

// 發完牌后電腦的手牌 
void PlayingCardsxsdn()
{
	printf("電腦\n");
	printf("   %d   %d   %d   %d   %d\n", 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("\t\t\t ****紙牌游戲****\n");
		printf("\t\t\t****1.游戲說明****\n");
		printf("\t\t\t****2.開始游戲****\n");
		printf("\t\t\t****3.開始出牌****\n");
		printf("\t\t\t****4.游戲結束****\n");
		printf("\t\t\t******************\n");
		puts("");
		printf("\t\t**********************************\n");
		printf("\t\t**********************************\n");
		puts("");
		printf("\t\t\t請輸入（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;
}         

關注博主不迷路，博主帶你碼代碼！