数据结构上机实验2——树——二叉树着色游戏

最新推荐文章于 2024-06-07 12:32:22 发布
最新推荐文章于 2024-06-07 12:32:22 发布
阅读量491 收藏 12
点赞数 1
分类专栏： 数据结构 文章标签： 二叉树 数据结构 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49119161/article/details/109897160
版权

利用easyx库设计并实现一个二叉树着色游戏
在这里插入图片描述
Tree.h

#ifndef TREE_H
#include <graphics.h>              // 引用图形库头文件
#include <easyx.h>
#include <conio.h>
#include <math.h>
#define MaxSize 50
#define LENGTH 1080
#define WIDTH 720
#define LINELENGTH floor(60*sqrt(2))
#define RADIUS floor(10*sqrt(2))
enum NodeColor { white, red, blue };
enum Direction { LEFT, RIGHT };
enum Players { one, two };
int x_tree = 540, y_tree = 60;
typedef struct PSTreeNode
{
	int val;            //值
	int color;          //颜色
	PSTreeNode* parent; //双亲结点
	PSTreeNode* lchild; //左孩子结点
	PSTreeNode* rchild; //右孩子结点
	int x;     //圆心x坐标
	int y;     //圆心y坐标
}PSTree;
//画树枝
void DrawLine(int xi, int yi, int xe, int ye, int flag) {
	int x1, x2;
	int y1 = yi + 10;
	int y2 = ye - 10;
	if (flag == LEFT) {
		x1 = xi - 10;
		x2 = xe + 10;
	}
	else if (flag == RIGHT) {
		x1 = xi + 10;
		x2 = xe - 10;
	}
	line(x1, y1, x2, y2);
}
//计算下一个结点圆心坐标
int* CircleCenter(int flag, int x, int y) {
	int a[2];
	static int n = 0;  //记录结点数
	static int h = 1;  //记录第几层
	static int xchange = 400;  //记录横坐标差值
	++n;
	if (n == pow(2, h - 1)) {
		h++;
		n = 0;
		xchange /= 2;
	}
	if (flag == LEFT) {
		a[0] = x - xchange;
		a[1] = y + 80;
	}
	else if (flag == RIGHT) {
		a[0] = x + xchange;
		a[1] = y + 80;
	}
	return a;
}
//点击的位置在圆内   x,y鼠标点击的坐标
bool InCircle(int x, int y, int xc, int yc) {
	if ((pow((xc - x), 2) + pow((yc - y), 2)) <= pow(RADIUS, 2))
	{
		return true;
	}
	else
		return false;
}
#endif // !TREE_H

Queue.h

#ifndef QUEUE_H
#include <stdio.h>
#include "tree.h"
//#define MaxSize 50
//typedef struct qnode
//{
//    PSTree* data;
//    struct qnode* next;
//}QNode;
typedef struct
{
    PSTree* data[MaxSize];
    int front, rear;
}LiQueue;
void InitQueue(LiQueue*& q)
{
    q = (LiQueue*)malloc(sizeof(LiQueue));
    q->front = q->rear = 0;
}
void DestroyQueue(LiQueue*& q)
{
    free(q);
}
bool QueueEmpty(LiQueue* q)
{
    return (q->rear == q->front);
}
bool enQueue(LiQueue*& q, PSTree* e)
{
    if ((q->rear + 1) % MaxSize == q->front) {
        return false;
    }
    q->rear = (q->rear + 1) % MaxSize;
    q->data[q->rear] = e;
    return true;
}
bool deQueue(LiQueue*& q, PSTree*& e)
{
    if (q->front == q->rear) {
        return false;
    }
    q->front = (q->front + 1) % MaxSize;
    e = q->data[q->front];
    return true;
}
#endif // !QUEUE_H

Best.h

#ifndef BEST_H
#include "queue.h"
//打印一号玩家胜率最大的点
void PlayerOne(int n, PSTree* tree, int& oneWin)
{
	int i = 1;
	PSTree* p = tree;
	while (p->rchild != NULL)
	{
		i++;
		p = p->rchild;
	}
	if (pow(2, i) - 1 == n)
	{
		outtextxy(30, 60, _T("1为player1胜率较大的位置"));
		oneWin = 1;
	}
	else if ((pow(2, i + 1) - 2 == n) && (pow(2, i) == n))
	{
		outtextxy(30, 60, _T("1或2为player1胜率较大的位置"));
	}
	else
	{
		outtextxy(30, 60, _T("2为player1胜率较大的位置"));
		oneWin = 2;
	}
	return;
}
//打印二号玩家胜率最大的点
void PlayerTwo(int n, PSTree* tree, int oneWin)
{
	int m, twoWin;
	PSTree* p = tree;
	LiQueue* qu;
	InitQueue(qu);
	enQueue(qu, p);
	while (!QueueEmpty(qu))
	{
		deQueue(qu, p);
		if (p->color == red)
		{
			m = p->val;
			break;
		}
		if (p->lchild != NULL)
		{
			enQueue(qu, p->lchild);
		}
		if (p->rchild != NULL)
		{
			enQueue(qu, p->rchild);
		}
	}
	if (m == oneWin)
	{
		outtextxy(30, 90, _T("player2无法获胜"));
		return;
	}
	if (p->parent != NULL)             //一号玩家不是根节点
	{
		twoWin = p->parent->val;
	}
	else                                           //一号玩家是根节点
	{
		twoWin = 2;
	}
	char c = '0' + twoWin;
	outtextxy(30, 90, c);
	outtextxy(40, 90, _T("为player2胜率较大的位置"));
	return;
}
#endif // !BEST_H

Game.h

#ifndef GAME_H
#include <windows.h>				//用到了定时函数sleep()
#include "best.h"
int whitecount = 0;     //白色结点个数
int player;             //当前玩家
int count = 0;          //第一次和第二次着色
bool playerone = true;  //玩家1有可走结点 
bool playertwo = true;  //玩家2有可走结点
int rec[] = { 940,30,1040,80 };//跳过按钮
//建立一个结点
PSTree* CreateNode(PSTree* parent, int x) {
    PSTree* tree = (PSTree*)malloc(sizeof(PSTree));
    tree->val = x;
    tree->lchild = NULL;
    tree->rchild = NULL;
    tree->parent = parent;
    tree->color = white;
    return tree;
}
//创建一棵树
PSTree* CreateTree(int root[], int n) {
    settextcolor(BLACK);
    setlinecolor(BLACK);
    outtextxy(30, 30, _T("二叉树着色游戏"));
    LiQueue* treeQueue;
    int i = 2, count = 1;
    InitQueue(treeQueue);
    PSTree* tree;
    PSTree* node = (PSTree*)malloc(sizeof(PSTree));
    //创建根节点
    tree = CreateNode(NULL, root[1]);
    tree->x = x_tree;
    tree->y = y_tree;
    node = tree;
    circle(node->x, node->y, RADIUS);
    enQueue(treeQueue, node);
    while (!QueueEmpty(treeQueue)) {
        deQueue(treeQueue, node);
        if (node->lchild == NULL) {
            PSTree* treeNode = CreateNode(node, root[i]);
            node->lchild = treeNode;
            int* xy = CircleCenter(LEFT, node->x, node->y);
            treeNode->x = xy[0];
            treeNode->y = xy[1];
            DrawLine(node->x, node->y, treeNode->x, treeNode->y, LEFT);
            circle(treeNode->x, treeNode->y, RADIUS);
            enQueue(treeQueue, treeNode);
            count++;
            i++;
            if (count == n || i > n) {
                break;
            }
        }
        if (node->rchild == NULL) {
            PSTree* treeNode = CreateNode(node, root[i]);
            node->rchild = treeNode;
            int* xy = CircleCenter(RIGHT, node->x, node->y);
            treeNode->x = xy[0];
            treeNode->y = xy[1];
            DrawLine(node->x, node->y, treeNode->x, treeNode->y, RIGHT);
            circle(treeNode->x, treeNode->y, RADIUS);
            enQueue(treeQueue, treeNode);
            count++;
            i++;
            if (count == n || i > n) {
                break;
            }
        }
    }
    DestroyQueue(treeQueue);
    return tree;
}
//游戏结束条件  所有结点都不是白色
bool GameOver(PSTree* tree, int n) {
    if (tree != NULL) {
        GameOver(tree->lchild, n);
        GameOver(tree->rchild, n);
        if (tree->color == white) {
            ++whitecount;
        }
        //有是白色的结点，说明游戏未结束
        if (whitecount != 0) {
            return false;
        }
        else {
            return true;
        }
    }
}
//跳过按钮
bool pass(int x,int y) {
    if (x > rec[0] && x<rec[2] && y>rec[1] && y < rec[3]) {
        if (player == one) {
            player = two;
            playerone = false;
            outtextxy(920, 100, _T("1号玩家无可走结点"));
            outtextxy(930, 125, _T("已切换到2号玩家"));
            return false;
        }
        else if (player == two) {
            player = one;
            playertwo = false;
            outtextxy(920, 100, _T("2号玩家无可走结点"));
            outtextxy(930, 125, _T("已切换到1号玩家"));
            return false;
        }
    }
    else {
        return false;
    }
}
//变色判断条件
void judge(PSTree* tree, int x, int y, PSTree* root, bool firORsec = false) {
    if (playerone && playertwo && pass(x, y)) {
        return;
    }
    if (!firORsec) {
        if (player == one
            && tree->color == white
            && InCircle(x, y, tree->x, tree->y) ) {
            if ((tree->parent == NULL
                && tree->lchild != NULL
                && tree->rchild != NULL
                && (tree->lchild->color == red || tree->rchild->color == red)
                && playerone)
                || (tree->parent != NULL
                    && tree->lchild == NULL
                    && tree->rchild == NULL
                    && tree->parent->color == red
                    && playerone)
                || (tree->parent != NULL
                    && tree->lchild != NULL
                    && tree->rchild != NULL
                    && (tree->lchild->color == red || tree->rchild->color == red || tree->parent->color == red)
                    && playerone)) {
                tree->color = red;
                clearcircle(tree->x, tree->y, RADIUS);
                setlinecolor(BLACK);
                setfillcolor(RED);
                circle(tree->x, tree->y, RADIUS);
                fillcircle(tree->x, tree->y, RADIUS);
                if (playertwo) {
                    player = two;
                }
            }
        }
        else if (player == two
            && tree->color == white
            && InCircle(x, y, tree->x, tree->y)) {
            if ((tree->parent == NULL
                && tree->lchild != NULL
                && tree->rchild != NULL
                && (tree->lchild->color == blue || tree->rchild->color == blue)
                && playertwo)
                || (tree->parent != NULL
                    && tree->lchild == NULL
                    && tree->rchild == NULL
                    && tree->parent->color == blue
                    && playertwo)
                || (tree->parent != NULL
                    && tree->lchild != NULL
                    && tree->rchild != NULL
                    && (tree->lchild->color == blue || tree->rchild->color == blue || tree->parent->color == blue)
                    && playertwo)) {
                tree->color = blue;
                clearcircle(tree->x, tree->y, RADIUS);
                setlinecolor(BLACK);
                setfillcolor(BLUE);
                circle(tree->x, tree->y, RADIUS);
                fillcircle(tree->x, tree->y, RADIUS);
                if (playerone) {
                    player = one;
                }
            }
        }
    }
    //第一次或第二次填充颜色时
    else {
        if (tree->color == white
            && InCircle(x, y, tree->x, tree->y)
            ) {
            if (count == 0) {
                tree->color = red;
                clearcircle(tree->x, tree->y, RADIUS);
                setlinecolor(BLACK);
                setfillcolor(RED);
                circle(tree->x, tree->y, RADIUS);
                fillcircle(tree->x, tree->y, RADIUS);
                ++count;
                player = two;
                return;
            }
            else if (count == 1) {
                tree->color = blue;
                clearcircle(tree->x, tree->y, RADIUS);
                setlinecolor(BLACK);
                setfillcolor(BLUE);
                circle(tree->x, tree->y, RADIUS);
                fillcircle(tree->x, tree->y, RADIUS);
                ++count;
                player = one;
                return;
            }
        }
    }
}
int WinPlayer(PSTree* root) {
    static int oneCount = 0;
    static int twoCount = 0;
    if (root != NULL) {
        WinPlayer(root->lchild);
        WinPlayer(root->rchild);
        if (root->color == red) {
            oneCount++;
        }
        else if (root->color == blue) {
            twoCount++;
        }
    }
    return (oneCount > twoCount) ? one : two;
}
void MouseClick(PSTree* root, int x, int y, int n, bool firORsec =false) {
    LiQueue* qu;
    InitQueue(qu);
    int count = 1;
    PSTree* node = (PSTree*)malloc(sizeof(PSTree));
    node = root;
    enQueue(qu, node);
    judge(node, x, y, root, firORsec);
    while (!QueueEmpty(qu)) {
        deQueue(qu, node);
        if (node->lchild != NULL) {
            enQueue(qu, node->lchild);
            judge(node->lchild, x, y, root, firORsec);
            count++;
            if (count == n) {
                break;
            }
        }
        if (node->rchild != NULL) {
            enQueue(qu, node->rchild);
            judge(node->rchild, x, y, root, firORsec);
            count++;
            if (count == n) {
                break;
            }
        }
    }
    DestroyQueue(qu);
}
void GamePlay() {
	initgraph(LENGTH, WIDTH);//初始化窗口（黑屏）
	for (int i = 0; i < 256; i += 5)
	{
		setbkcolor(RGB(i, i, i));//设置背景色，原来默认黑色
		cleardevice();//清屏（取决于背景色）
		Sleep(15);//延时15ms
	}
	int root[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    player = one;
    int length = sizeof(root) / sizeof(int) - 1;
    bool firORsec = true;
    PSTree* tree = CreateTree(root, length);
    RECT rect = { rec[0], rec[1], rec[2], rec[3] };
    rectangle(rec[0], rec[1], rec[2], rec[3]);
    drawtext(_T("pass"), &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    int oneWin = 0;
    PlayerOne(length, tree, oneWin);
    MOUSEMSG m;//鼠标指针
    setrop2(R2_NOTXORPEN);//二元光栅——NOT(屏幕颜色 XOR 当前颜色)
    while (!GameOver(tree, length))
    {
        m = GetMouseMsg();//获取一条鼠标消息
        
        if (m.uMsg == WM_LBUTTONDOWN && firORsec)
        {
            for (int i = 0; i <= 10; i++)
            {
                setlinecolor(RGB(25 * i, 25 * i, 25 * i));//设置圆颜色
                circle(m.x, m.y, 2 * i);
                Sleep(25);//停顿2ms
                circle(m.x, m.y, 2 * i);//抹去刚刚画的圆
            }
            MouseClick(tree, m.x, m.y, length, firORsec);
            if (count == 1) {
                PlayerTwo(length, tree, oneWin);
            }
            //判断是否已经画了两个结点了
            if (count >= 2) {
                firORsec = false;
            }
            FlushMouseMsgBuffer();//清空鼠标消息缓存区
        }
        else if(m.uMsg == WM_LBUTTONDOWN && !firORsec){
            for (int i = 0; i <= 10; i++)
            {
                setlinecolor(RGB(25 * i, 25 * i, 25 * i));//设置圆颜色
                circle(m.x, m.y, 2 * i);
                Sleep(25);//停顿2ms
                circle(m.x, m.y, 2 * i);//抹去刚刚画的圆
            }
            MouseClick(tree, m.x, m.y, length);
            FlushMouseMsgBuffer();//清空鼠标消息缓存区
        }
        whitecount = 0;
    }
    settextcolor(BLACK);
    if (WinPlayer(tree) == one) {
        TCHAR s[] = _T("1号玩家获胜");
        outtextxy(510, 680, s);
    }
    else if (WinPlayer(tree) == two) {
        TCHAR s[] = _T("2号玩家获胜");
        outtextxy(510, 680, s);
    }
	system("pause");//暂停，为了显示
	closegraph();
}
#endif // !GAME_H

main.cpp

#include "game.h"
//完全二叉树   结点个数为奇数
int main()
{
	GamePlay();
	return 0;
}
zcharlotteyq
关注
专栏目录
EasyX_20151015(beta)
11-18
绿色安全的一个EasyX插件安装包。
LeetCode 1145. 二叉树着色游戏（C++）
Panbk的博客
03-01 217
一场「二叉树着色」的游戏。游戏中，给出二叉树的根节点 root，树上总共有 n 个节点，且 n 为奇数，其中每个节点上的值从 1 到 n 各不相同。 一号」玩家先手。每一回合，玩家选择一个被他染过色的节点，将所选节点一个 未着色 的邻节点进行染色。如果当前玩家无法找到这样的节点来染色时，其回合就会被跳过。若两个玩家都没有可以染色的节点时，游戏结束。着色节点最多的那位玩家获得胜利。 假设你是「二号」玩家，假如存在一个 y 值可以确保你赢得这场游戏，则返回 true ；若无法获胜，就请返回 false
完全二叉树的层序遍历游戏
一个腰部以上的叛逆
01-13 2283
聊以自娱的玩意，各位想看就看看吧。越写越垃圾。
LeetCode 1145. 二叉树着色游戏（树的遍历、树的连通块、统计节点数目）
SongyangJi
06-14 546
二叉树着色游戏 假如说图中的灰色的②号节点就是一号玩家选择的点,那么二号玩家尽可能有利的选择是它的 左右子节点或者父节点。 那么如果二号玩家想要获胜，必须占领左边，右边、其他部分的所有节点，而且这部分节点的数目要超过一半。 用后序遍历求得一棵树的节点数目。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right;
超级详细二叉树（包含EASYX画图）|数据结构
LLLLQZ的博客
11-03 3379
花了好久弄好的二叉树代码，希望能帮到你们 超级详细二叉树实现1、二叉树程序功能前情提要 ！！！1.1主菜单功能：1.前序创建二叉树2.前中后序输出3.统计叶子数4.复制二叉树5.交换左右子树6.计算二叉树高度7.输出叶子结点到根结点所有路径8.输出叶子结点到根结点最长路径9.二叉树的所有关系10.字符模式画二叉树11.easyx画二叉树1.2子菜单功能：1.根、叶节点2.结点的双亲 祖先 孩子 子孙 兄弟3.结点的层次4.树的深度5.以某个结点为根的子树的深度 1、二叉树程序功能 前情提要 ！！！ 头文件：
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
数据结构实验报告——树.docx
12-05
数据结构实验报告——树 本实验报告主要围绕数据结构中的树这一主题，特别是涉及赫夫曼树（Huffman Tree）的构建与应用。赫夫曼树是一种特殊的二叉树，常用于数据压缩，通过构建最小带权路径长度的二叉树来实现可变...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
超级详细的二叉树.rar
11-03
超级详细的二叉树
二叉树演示软件
09-11
本人在学习过程中编写的一个二叉树演示软件，功能齐全，但是逻辑还不是很清晰，可以拿来演示教学使用、自己学习使用。有需要代码的发邮件到447861996@qq.com 提供代码。可以进一步完善~~
数据结构上机实验——遍历二叉树
05-01
用C语言编写的遍历二叉树程序，包括先序、中序、后序、层序4总算法，完整的上机报告，报告中有程序源代码，经编译通过。
easy x画图工具合集
06-27
一个有用的才语言画图工具合集，需要的童鞋可以下载来用
上机实验3-二叉树
11-25
1.输入一个中缀表达式，构造表达式树，以文本方式输出树结构。 输入：例如，输入a+b+c*(d+e) 输出：以缩进表示二叉树的层次，左（根），右（叶），上（右子树），下（左子树） 2.编写二叉树类的成员函数，分别实现以下功能： ①交换二叉树中所有节点的左右子树。（将结果输出至文本文件中） ②按层次顺序遍历二叉树：首先访问根节点，然后是它的两个孩子节点，然后是孙子节点，依此类推。（将结果输出至屏幕） 求二叉树的宽度，即同一层次上最多的节点数。（将结果输出至屏幕） 含实验报告
期末复习笔记——树和二叉树
weixin_52640021的博客
12-06 1031
前言 一、树 1，树型结构 树型结构是一种非线性结构，与之前的线性表，栈，队列还有字符串，数组，广义表不同。相比与之前一对一的线性结构，树型结构展示为一对多的非线性结构。 2，树的定义，术语，森林 太多了，不打了。。。直接二叉树 二、二叉树 二叉树，这个树比较重要，结构简单，规律性强，普通树也可以通过转化为二叉树进行运算，简化步骤。其中运用二叉树的算法也有很多，像最优二叉..
平衡搜索二叉树之红黑树（拒绝死记硬背，拥抱理解记忆）
qq_68140277的博客
03-21 2173
在了解完平衡搜索二叉树的优势和应用后，我们学习了AVL树这种方案来实现它，但在前人们的不断使用和开辟，另一种更优的方案横空出世——红黑树。
数据结构与算法分析实验6 [进阶]构建二叉树并进行图形化遍历（EasyX）
最新发布
2301_81290340的博客
06-07 972
数据结构与算法分析实验 二叉树进阶 通过EasyX图形库实现了树的遍历绘制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值