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

于 2020-11-21 14:31:15 发布
阅读量462 收藏 11
点赞数 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
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EasyX_20151015(beta)
11-18
绿色安全的一个EasyX插件安装包。
期末复习笔记——树和二叉树
weixin_52640021的博客
12-06 972
前言 一、树 1，树型结构 树型结构是一种非线性结构，与之前的线性表，栈，队列还有字符串，数组，广义表不同。相比与之前一对一的线性结构，树型结构展示为一对多的非线性结构。 2，树的定义，术语，森林 太多了，不打了。。。直接二叉树 二、二叉树 二叉树，这个树比较重要，结构简单，规律性强，普通树也可以通过转化为二叉树进行运算，简化步骤。其中运用二叉树的算法也有很多，像最优二叉..
【LB】图形化编程与二叉树的应用
poklau的专栏
04-14 1476
C语言实现图形化编程，最直接的方式是通过graphics.h来实现，但它只在TC编译器中能用，要想在vc中使用，目前仅有的办法是通过easyx软件导入函数库。传送门：http://www.easyx.cn/。进去后下载，将文件解压后安装就行。图形编程既简单又有意思，还能做出很多有用的东西来，推荐大家没事去学学！         整个程序目前实现了两个功能，一个是通过输入先序序列和中序序列来画出二
上机实验3-二叉树
11-25
1.输入一个中缀表达式，构造表达式树，以文本方式输出树结构。 输入：例如，输入a+b+c*(d+e) 输出：以缩进表示二叉树的层次，左（根），右（叶），上（右子树），下（左子树） 2.编写二叉树类的成员函数，分别实现以下功能： ①交换二叉树中所有节点的左右子树。（将结果输出至文本文件中） ②按层次顺序遍历二叉树：首先访问根节点，然后是它的两个孩子节点，然后是孙子节点，依此类推。（将结果输出至屏幕） 求二叉树的宽度，即同一层次上最多的节点数。（将结果输出至屏幕） 含实验报告
实现由先序、中序序, 中序、后序构造二叉树的算法
11-29
定义二叉树类，封装构造二叉树操作、遍历操作. 实现由先序、中序序列构造二叉树的算法 实现由后序、中序序列构造二叉树的算法
广工数据结构实验——平衡二叉树
07-06
广工数据结构实验——平衡二叉树 里面含有：源代码、可执行程序、说明文档
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
数据结构实验——树和二叉树子系统
07-31
按屏幕提示用前序方法建立一棵二叉树；编写前序遍历、中序遍历、后序遍历、层次遍历程序；求二叉树的叶结点数、总结点数和深度；设计一个选择式菜单，以菜单方式选择下列操作。
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
超级详细的二叉树.rar
11-03
超级详细的二叉树
二叉树演示软件
09-11
本人在学习过程中编写的一个二叉树演示软件，功能齐全，但是逻辑还不是很清晰，可以拿来演示教学使用、自己学习使用。有需要代码的发邮件到447861996@qq.com 提供代码。可以进一步完善~~
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
广工数据结构课程设计——平衡二叉树操作的演示
07-06
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
武汉理工大学计算机数据结构与算法实验一——二叉树与哈夫曼图片压缩
06-03
(1)掌握树的存储结构 (2)掌握二叉树的三种遍历方法 (3)掌握并理解Huffman树、Huffman编码等知识和应用 (4)掌握文件的操作 (5)使用Huffman算法实现图像压缩程序 2.实验内容 使用Huffman压缩算法，对一幅BMP格式的...
模拟——洛谷P1185 绘制二叉树
我怎么这么菜的呢
05-28 1006
https://www.luogu.org/problem/show?pid=1185 哈哈，我的代码是唯一一个不到1kb的； 时间不是最快的，但是我的代码没用hk跑； 要用hk跑的话，估计也快的飞起； 一看题目就感觉很有意思； 我的方法简单来说就是先找规律，然后一个dfs绘图； 首先我们考虑满二叉树； 我们先要确定画布大小； 然后juicy可以找到这么一种规律； 当k=1的时候，
c/c++ 显示图形二叉树
The_Only_God的博客
12-01 1941
文章目录头文件数据结构 头文件 #include<easyx.h> #include<conio.h> easyx库下载地址link 数据结构 二叉链表 typedef struct BSTNode { int key; BSTNode* lchild, * rchild; }BSTNode,*BSTree;//二叉树结点 ...
使用graphviz绘制二叉树
给永远比拿愉快
05-12 9937
Graphviz是开源免费跨平台图形绘制工具，使用其提供的dot语法，可以很方便的用来绘制“图”结构（这里的图可以理解为是数学上或者计算机科学中所说的图），并支持多种格式输出。语法首先，来简单看一下dot语法。 1. 使用digraph关键字定义有向图，使用->表述节点之间的关系。如: （g是图的名称，a，b，c是三个节点）digraph g { a->b; b->c; c->a;
easyX实现鼠标人物移动（可视化编程）
Swust_ZzK的博客
05-10 8892
#include #include #include #include #pragma comment(lib,"WINMM.lib") struct { int x, y;//人物坐标 int _x, _y;//目的地坐标 int dir;//人物移动方向 /* 0 下 ，1 左 2，右 3，下 4 左下 5 右下 6，左上 7 右上 */ int nu
C++数据结构——中序遍历二叉树
最新发布
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值