easyX输入先序遍历二叉树

以下是使用递归方法输入先序遍历二叉树的代码：

#include <graphics.h>

// 二叉树节点结构体
struct TreeNode {
    int value;
    TreeNode* left;
    TreeNode* right;
};

// 递归方法输入先序遍历二叉树
TreeNode* inputTree() {
    int value;
    scanf("%d", &value);
    if (value == -1) {  // 输入 -1 表示空节点
        return nullptr;
    }
    TreeNode* root = new TreeNode{value, nullptr, nullptr};
    root->left = inputTree();
    root->right = inputTree();
    return root;
}

int main() {
    initgraph(640, 480);
    setbkcolor(WHITE);

    // 输入二叉树
    TreeNode* root = inputTree();

    // 其他操作

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

注意，这里只是输入二叉树的方法，需要根据实际需求进行其他操作。

相关问题

使用 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实现二叉树遍历

下面是使用easyx图形库实现二叉树的遍历的示例代码：

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

const int WIDTH = 800; // 窗口宽度
const int HEIGHT = 600; // 窗口高度
const int RADIUS = 25; // 节点半径
const int DISTANCE_X = 50; // 节点之间的水平距离
const int DISTANCE_Y = 70; // 节点之间的垂直距离

// 二叉树节点结构体
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 画节点
void drawNode(int x, int y, int val) {
    setlinecolor(BLACK);
    setfillcolor(LIGHTGRAY);
    fillellipse(x, y, RADIUS, RADIUS);
    setbkmode(TRANSPARENT);
    settextstyle(20, 0, _T("Arial"));
    settextcolor(BLACK);
    TCHAR str[10];
    _stprintf_s(str, _T("%d"), val);
    outtextxy(x - 10, y - 10, str);
}

// 画边
void drawEdge(int x1, int y1, int x2, int y2) {
    setlinecolor(BLACK);
    setlinestyle(PS_SOLID, 2);
    line(x1, y1 + RADIUS, x2, y2 - RADIUS);
}

// 递归先序遍历
void preOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    drawNode(root->val, root->val * DISTANCE_Y, root->val);
    if (root->left) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->left->val, root->left->val * DISTANCE_Y);
    }
    if (root->right) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->right->val, root->right->val * DISTANCE_Y);
    }
    preOrder(root->left);
    preOrder(root->right);
}

// 递归中序遍历
void inOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inOrder(root->left);
    drawNode(root->val, root->val * DISTANCE_Y, root->val);
    if (root->left) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->left->val, root->left->val * DISTANCE_Y);
    }
    if (root->right) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->right->val, root->right->val * DISTANCE_Y);
    }
    inOrder(root->right);
}

// 递归后序遍历
void postOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postOrder(root->left);
    postOrder(root->right);
    drawNode(root->val, root->val * DISTANCE_Y, root->val);
    if (root->left) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->left->val, root->left->val * DISTANCE_Y);
    }
    if (root->right) {
        drawEdge(root->val, root->val * DISTANCE_Y, root->right->val, root->right->val * DISTANCE_Y);
    }
}

// 层序遍历
void levelOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        drawNode(node->val, node->val * DISTANCE_Y, node->val);
        if (node->left) {
            drawEdge(node->val, node->val * DISTANCE_Y, node->left->val, node->left->val * DISTANCE_Y);
            q.push(node->left);
        }
        if (node->right) {
            drawEdge(node->val, node->val * DISTANCE_Y, node->right->val, node->right->val * DISTANCE_Y);
            q.push(node->right);
        }
    }
}

int main() {
    initgraph(WIDTH, HEIGHT); // 初始化图形窗口
    setbkcolor(WHITE); // 设置背景颜色
    cleardevice(); // 清屏
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);
    //preOrder(root);
    //inOrder(root);
    //postOrder(root);
    levelOrder(root);
    getch(); // 暂停窗口
    closegraph(); // 关闭图形窗口
    return 0;
}

在Visual Studio中，需要配置easyx头文件和库文件路径，否则编译会出错。具体方法可以参考easyx官方文档或者网上其他教程。