建立二叉树c语言代码

以下是建立二叉树的C语言代码：

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

typedef struct TreeNode {
    char val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

TreeNode* createTree() {
    char c;
    scanf("%c", &c);
    if (c == '#') { // #表示空节点
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = c;
    root->left = createTree();
    root->right = createTree();
    return root;
}

该代码中，我们定义了一个结构体`TreeNode`，包含了二叉树的数据域`val`和左右子树的指针`left`和`right`。`createTree`函数用于创建二叉树，通过递归的方式实现。在函数中，我们首先读入一个字符，如果该字符为`#`，则返回空节点；否则，我们新建一个节点，并将该字符赋值给节点的数据域。然后，我们递归调用`createTree`函数，分别将左右子树的指针赋值给当前节点的左右子树指针，最后返回根节点。

相关问题

按先序次序建立一个二叉树c语言代码实现

### 回答1：
以下是一个简单的示例代码，实现先序遍历方式创建二叉树：

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

typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

TreeNode* createBinaryTree() {
    int val;
    printf("Enter the value of node (enter -1 for NULL): ");
    scanf("%d", &val);

    if (val == -1) {
        return NULL;
    }

    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->val = val;

    printf("Enter the left child of %d:\n", val);
    newNode->left = createBinaryTree();

    printf("Enter the right child of %d:\n", val);
    newNode->right = createBinaryTree();

    return newNode;
}

void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->val);
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

int main() {
    TreeNode* root = NULL;
    printf("Create binary tree:\n");
    root = createBinaryTree();

    printf("\nPreorder Traversal: ");
    preorderTraversal(root);

    return 0;
}

用户输入每个节点的值，如果该节点为空，则输入-1。程序会递归地创建左子树和右子树，然后返回根节点。最后，使用先序遍历方式输出二叉树。

### 回答2：
下面是一个按照先序顺序建立二叉树的C语言实现代码：

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

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

struct TreeNode* createTree() {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    printf("请输入节点的值（-1表示空节点）：");
    scanf("%d", &(newNode->data));

    if (newNode->data == -1) {
        return NULL;
    }

    printf("创建左子树：");
    newNode->left = createTree();
    
    printf("创建右子树：");
    newNode->right = createTree();

    return newNode;
}

void preOrder(struct TreeNode* root) {
    if (root != NULL) {
        printf("%d ", root->data);
        preOrder(root->left);
        preOrder(root->right);
    }
}

int main() {
    struct TreeNode* root = createTree();
    printf("先序遍历结果为：");
    preOrder(root);

    return 0;
}

此代码中，我们首先定义了一个二叉树的节点结构`TreeNode`。在`createTree`函数中，通过递归的方式按照用户输入的先序顺序创建二叉树，用户输入-1表示空节点。`preOrder`函数用于先序遍历二叉树并打印节点的值。

在主函数中，我们先调用`createTree`函数创建二叉树，并将返回的根节点赋值给`root`。然后调用`preOrder`函数对该二叉树进行先序遍历，并打印遍历结果。

### 回答3：
下面是一个使用C语言实现的按照先序顺序构建二叉树的例子：

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

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

struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("内存分配失败！");
        exit(1);
    }
    
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

struct Node* buildTree(int preorder[], int* index) {
    if (preorder[*index] == -1) {
        return NULL;
    }
    
    struct Node* rootNode = createNode(preorder[*index]);
    (*index)++;
    
    rootNode->left = buildTree(preorder, index);
    (*index)++;
    
    rootNode->right = buildTree(preorder, index);
    
    return rootNode;
}

void inorderTraversal(struct Node* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

int main() {
    int preorder[] = {1, 2, 4, -1, -1, 5, -1, -1, 3, -1, 6, -1, -1};
    int index = 0;
    
    struct Node* root = buildTree(preorder, &index);
    
    printf("二叉树的中序遍历结果为：");
    inorderTraversal(root);
    
    return 0;
}

以上代码实现了按照先序顺序（先根节点，然后左子树，最后右子树）构建一个二叉树，并实现了中序遍历（先左子树，然后根节点，最后右子树）。在主函数中，预先定义了一个先序遍历数组`preorder`作为输入，它的元素为树节点的值，-1表示空节点。通过调用`buildTree`函数，根据先序遍历数组构建二叉树，并返回根节点。最后，调用`inorderTraversal`函数进行中序遍历，并输出遍历结果。

先序遍历建立二叉树，c语言代码

先序遍历建立二叉树是一种利用先序遍历的方式递归地创建二叉树的算法。在这个过程中，我们首先访问根节点，然后是左子树，最后是右子树。在C语言中，我们通常会定义一个二叉树节点的结构体，然后通过递归函数来根据先序遍历的顺序构建这棵树。

以下是一个简单的C语言代码示例，演示如何使用先序遍历的方式建立二叉树：

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

// 定义二叉树节点的结构体
typedef struct TreeNode {
    char data; // 假设树中存储的是字符类型数据
    struct TreeNode *left; // 左子树指针
    struct TreeNode *right; // 右子树指针
} TreeNode;

// 函数声明
TreeNode* createTree();

// 主函数
int main() {
    TreeNode* root = createTree();
    // 这里可以添加代码来验证树的建立是否成功，例如进行先序遍历打印节点等
    // ...

    // 释放分配的内存（注意：这里没有实现释放内存的代码，实际使用时应该递归释放所有节点的内存）
    // ...

    return 0;
}

// 递归创建二叉树的函数
TreeNode* createTree() {
    char ch;
    scanf(" %c", &ch); // 读取一个字符，注意在%c前面有一个空格，用来忽略空白字符

    // 建立一个新节点
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    if (!node) {
        printf("内存分配失败。\n");
        return NULL;
    }

    node->data = ch; // 将读取的字符赋值给节点数据域

    if (ch == '#') { // 如果读取的是结束标记，则返回NULL
        node->left = node->right = NULL;
    } else {
        node->left = createTree(); // 递归创建左子树
        node->right = createTree(); // 递归创建右子树
    }
    return node;
}

这段代码中，我们使用`createTree`函数递归地构建二叉树。它读取一个字符，并根据该字符是否为结束标记`#`来决定是否创建子树。如果是`#`，则对应的左子树或右子树为空。如果不是`#`，则继续读取左右子树的数据并递归地建立子树。

请注意，这个代码示例假设用户输入的二叉树节点是单个字符，并且使用`#`字符来标记某个节点的子树为空。在实际使用中，你可能需要根据实际需求来调整代码，比如节点中存储的数据类型，以及如何结束输入等。