easyx怎么在任意的坐标填充颜色

在 EasyX 中，可以使用 `setfillcolor` 函数来设置填充颜色，使用 `solidrectangle` 函数来绘制矩形并填充颜色。例如，如果要在坐标为 `(x, y)` 的位置填充红色，可以使用以下代码：

setfillcolor(RED);
solidrectangle(x, y, x + 50, y + 50);

其中 `RED` 是预定义的颜色常量，表示红色。`solidrectangle` 函数的前两个参数是矩形左上角的坐标，后两个参数是矩形右下角的坐标，这里我们假设矩形的大小为 50x50。通过这段代码，就可以在 `(x, y)` 的位置填充红色。

相关问题

使用 easyx 绘制先序遍历的 C++ 代码，并在遍历时改变遍历的节点的颜色。

### 回答1：
以下是使用 easyx 绘制先序遍历并改变节点颜色的 C++ 代码：

#include <graphics.h>
#include <conio.h>
#include <iostream>
#include <stack>
using namespace std;

const int MAXN = 105;           // 最大节点数
const int nodeSize = 30;        // 节点大小
const int interval = 50;        // 节点间距

int n;                          // 节点数
int preorder[MAXN];             // 先序遍历序列
int inorder[MAXN];              // 中序遍历序列
int nodeColor[MAXN];            // 节点颜色，0表示白色，1表示红色

struct TreeNode {
    int val;                    // 节点值
    int x, y;                   // 节点坐标
};

// 根据先序和中序遍历序列构建二叉树
TreeNode* buildTree(int preL, int preR, int inL, int inR) {
    if (preL > preR) return NULL;
    int rootVal = preorder[preL];
    int k = inL;
    while (inorder[k] != rootVal) k++;
    TreeNode* root = new TreeNode{ rootVal, 0, 0 };
    root->x = (preL + preR) * interval / 2;
    root->y = (inL + inR) * interval / 2;
    root->val = rootVal;
    root->left = buildTree(preL + 1, preL + k - inL, inL, k - 1);
    root->right = buildTree(preL + k - inL + 1, preR, k + 1, inR);
    return root;
}

// 绘制节点
void drawNode(TreeNode* p) {
    if (nodeColor[p->val] == 1) setfillcolor(RED);
    else setfillcolor(WHITE);
    setlinecolor(BLACK);
    fillellipse(p->x, p->y, nodeSize, nodeSize);
    settextcolor(BLACK);
    char str[10];
    sprintf_s(str, "%d", p->val);
    outtextxy(p->x - 7, p->y - 7, str);
}

// 先序遍历并绘制二叉树
void preorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    drawNode(root);
    nodeColor[root->val] = 1;   // 标记为红色
    Sleep(500);                 // 等待0.5秒
    preorderTraversal(root->left);
    preorderTraversal(root->right);
    nodeColor[root->val] = 0;   // 标记为白色
    drawNode(root);
}

// 初始化窗口
void initWindow() {
    initgraph(800, 600);
    setbkcolor(WHITE);
    cleardevice();
    setlinestyle(PS_SOLID, 1);
}

int main() {
    initWindow();

    // 读入节点数和先序、中序遍历序列
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> preorder[i];
    for (int i = 0; i < n; i++)
        cin >> inorder[i];

    // 构建二叉树
    TreeNode* root = buildTree(0, n - 1, 0, n - 1);

    // 先序遍历并绘制二叉树
    preorderTraversal(root);

    getch();
    closegraph();
    return 0;
}

在这个程序中，我们使用了 `graphics.h` 库来绘制图形界面，使用了 `stack` 来实现非递归遍历二叉树。我们首先读入节点数和先序、中序遍历序列，构建二叉树。然后，我们通过先序遍历的方式遍历二叉树，并在绘制每个节点时改变其颜色，以此来实现动态效果。为了让用户能够看到每个节点的颜色变化，我们在改变节点颜色后使用 `Sleep(500)` 命令使程序暂停 0.5 秒。

注意，在这个程序中，我们使用了 `nodeColor` 数组来记录每个节点的颜色。如果 `nodeColor[i]` 的值为 0，则表示第 i 个节点为白色；如果 `nodeColor[i]` 的值为 1，则表示第 i 个节点为红色。在绘制每个节点时，我们根据 `nodeColor` 数组的值来决定节点的填充颜色。在遍历每个节点时，我们先将其颜色标记为红色，遍历完以后再将其标记为白色。

### 回答2：
使用easyx绘制先序遍历的C代码，并在遍历时改变遍历节点的颜色，可以参考下面的代码：

#include <stdio.h>
#include <conio.h>
#include <graphics.h>
#include <stdlib.h>

#define MAX_NODE 100 // 最大节点数

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// 创建二叉树节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 先序遍历二叉树，并改变节点颜色
void preorderTraversal(struct Node* node) {
    if (node != NULL) {
        setfillcolor(RED); // 设置节点颜色为红色
        fillcircle(node->data * 20, 30, 15); // 绘制节点
        delay(500); // 延时0.5秒，以便观察
        setfillcolor(WHITE); // 设置节点颜色为白色
        fillcircle(node->data * 20, 30, 15); // 清除节点颜色
        preorderTraversal(node->left); // 先序遍历左子树
        preorderTraversal(node->right); // 先序遍历右子树
    }
}

// 主函数
int main() {
    struct Node* root = createNode(1); // 创建根节点
    root->left = createNode(2); // 创建左子节点
    root->right = createNode(3); // 创建右子节点
    root->left->left = createNode(4); // 创建左孙节点
    root->left->right = createNode(5); // 创建右孙节点

    initgraph(640, 480); // 初始化图形窗口
    setbkcolor(BLACK); // 设置背景颜色为黑色
    cleardevice(); // 清屏

    preorderTraversal(root); // 先序遍历并改变节点颜色

    _getch(); // 按任意键退出
    closegraph(); // 关闭图形窗口
    return 0;
}

此代码使用easyx库创建一个简单的图形窗口，并通过先序遍历二叉树的方式逐个改变节点的颜色，通过设置节点的颜色为红色，在绘制之前，延时一段时间以便观察，然后再设置节点颜色为白色，以清除颜色。

通过这段代码，您可以在图形窗口中看到二叉树各节点的先序遍历过程，并在遍历时改变节点的颜色。

### 回答3：
使用easyx库绘制先序遍历的C代码并改变遍历节点的颜色，可以按照以下步骤进行操作：

1. 导入easyx库，并创建一个窗口。
2. 定义二叉树的结构体，包含节点值和左右子节点指针。
3. 定义一个函数来创建二叉树，并输入二叉树的节点。
4. 定义一个先序遍历函数，用递归的方式进行遍历，并在遍历节点之后改变节点的颜色。
5. 在窗口中调用先序遍历函数，并实时刷新窗口。

以下是一个可能的实现代码：

#include <conio.h>
#include <graphics.h>

struct TreeNode {
    int value;
    struct TreeNode* left;
    struct TreeNode* right;
};

void createTree(struct TreeNode** root) {
    int val;
    scanf("%d", &val);

    if (val == -1) {
        *root = NULL;
    } else {
        *root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        (*root)->value = val;

        createTree(&(*root)->left);
        createTree(&(*root)->right);
    }
}

void preOrderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }

    // 改变节点颜色
    setcolor(YELLOW);
    circle(320, 240, 10);
    outtextxy(320, 240, to_string(root->value).c_str());
    delay(500);
    setcolor(BLACK);
    circle(320, 240, 10);
    outtextxy(320, 240, to_string(root->value).c_str());

    preOrderTraversal(root->left);
    preOrderTraversal(root->right);
}

int main() {
    initgraph(640, 480);
    struct TreeNode* root = NULL;
    printf("输入二叉树的节点：\n");
    createTree(&root);

    printf("先序遍历结果：\n");
    preOrderTraversal(root);

    getch();
    closegraph();
    return 0;
}

以上代码利用easyx库的图形函数绘制窗口，并通过先序遍历函数在遍历节点时改变节点的颜色，从而实现了绘制先序遍历并改变节点颜色的功能。注意，在使用该代码时需要在计算机上安装easyx库，并在编译选项中链接相关库文件。

使用EasyX库用C语言设计一个绘制多边形的程序。并且满足以下要求：用鼠标左键可以绘制任意个多边形；过程中要显示绘制路径，鼠标右键结束绘制，绘制结束后 ，填充多边形内部； 按键盘S键将已绘制完成的多边形坐标保存到文件中，按键盘L键从文件中读取已保存的多边形坐标，重新显示在界面上。

好的，以下是实现绘制多边形的程序，使用EasyX库和C语言：

#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_POINTS 100 // 多边形最大点数
#define FILENAME "polygon.txt" // 保存多边形坐标的文件名

typedef struct {
    int x, y;
} Point; // 点结构体

Point points[MAX_POINTS]; // 保存多边形点的数组
int pointCount = 0; // 已绘制点的数量
int polygonCount = 0; // 已绘制多边形的数量

void drawPolygon() {
    setlinecolor(RED);
    for (int i = 0; i < pointCount - 1; i++) {
        line(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y);
    }
}

void fillPolygon() {
    setfillcolor(GREEN);
    fillpolygon(points, pointCount);
}

void savePolygon() {
    FILE *fp;
    if ((fp = fopen(FILENAME, "a")) == NULL) {
        printf("无法打开文件 %s。\n", FILENAME);
        return;
    }
    fprintf(fp, "%d ", pointCount);
    for (int i = 0; i < pointCount; i++) {
        fprintf(fp, "%d %d ", points[i].x, points[i].y);
    }
    fprintf(fp, "\n");
    fclose(fp);
}

void loadPolygon() {
    FILE *fp;
    if ((fp = fopen(FILENAME, "r")) == NULL) {
        printf("无法打开文件 %s。\n", FILENAME);
        return;
    }
    while (!feof(fp)) {
        int count;
        fscanf(fp, "%d", &count);
        if (count == 0) {
            break;
        }
        for (int i = 0; i < count; i++) {
            fscanf(fp, "%d %d", &points[i].x, &points[i].y);
        }
        pointCount = count;
        drawPolygon();
        fillPolygon();
        polygonCount++;
    }
    fclose(fp);
}

int main() {
    initgraph(640, 480); // 初始化画布
    setbkcolor(WHITE); // 设置背景颜色
    cleardevice(); // 清空画布

    registermouseevent(WM_LBUTTONDOWN, MOUSEEVENT_LEFTDOWN); // 注册鼠标左键按下事件
    registermouseevent(WM_RBUTTONDOWN, MOUSEEVENT_RIGHTDOWN); // 注册鼠标右键按下事件
    registerkeyevent(WM_KEYDOWN, 'S'); // 注册键盘S键按下事件
    registerkeyevent(WM_KEYDOWN, 'L'); // 注册键盘L键按下事件
    loadPolygon(); // 从文件中读取已保存的多边形坐标并绘制

    while (1) {
        MOUSEMSG m;
        while (MouseHit()) {
            m = GetMouseMsg();
            if (m.uMsg == WM_LBUTTONDOWN) { // 鼠标左键按下事件
                points[pointCount].x = m.x;
                points[pointCount].y = m.y;
                pointCount++;
                if (pointCount > 1) {
                    setlinecolor(RED);
                    line(points[pointCount - 2].x, points[pointCount - 2].y, m.x, m.y);
                }
            } else if (m.uMsg == WM_RBUTTONDOWN) { // 鼠标右键按下事件
                setlinecolor(WHITE);
                line(points[pointCount - 1].x, points[pointCount - 1].y, points[0].x, points[0].y);
                fillPolygon();
                polygonCount++;
                pointCount = 0;
                savePolygon();
            }
        }
        if (kbhit()) {
            char c = getch();
            if (c == 'S' || c == 's') { // 键盘S键按下事件
                savePolygon();
            } else if (c == 'L' || c == 'l') { // 键盘L键按下事件
                cleardevice();
                polygonCount = 0;
                loadPolygon();
            }
        }
    }

    closegraph(); // 关闭画布
    return 0;
}

程序的主要流程如下：

1. 初始化画布，注册鼠标和键盘事件，从文件中读取已保存的多边形坐标并绘制。
2. 当鼠标左键按下时，记录下当前鼠标位置，绘制从上一个点到当前点的线段，更新已绘制点的数量。
3. 当鼠标右键按下时，绘制最后一个点到第一个点的线段，填充多边形内部，更新已绘制多边形的数量和已绘制点的数量，并将多边形坐标保存到文件中。
4. 当键盘S键按下时，将已绘制完成的多边形坐标保存到文件中。
5. 当键盘L键按下时，清空画布，重新从文件中读取已保存的多边形坐标并绘制。

注意：程序中使用了EasyX库的函数和结构体，需要在编译时链接EasyX库。