用c语言写一个按层次遍历建立二叉树

### 回答1：
可以使用队列来实现按层次遍历建立二叉树的算法，具体步骤如下：

1. 定义一个队列，将根节点入队。
2. 循环执行以下步骤，直到队列为空：
a. 出队一个节点，作为当前节点。
b. 读入当前节点的左子节点和右子节点的值，如果有值则创建新节点并将其入队，否则将 NULL 入队。
c. 将新节点作为当前节点的左子节点或右子节点。
3. 返回根节点。

具体的 C 语言代码如下：

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

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

typedef struct QueueNode {
    TreeNode *node;
    struct QueueNode *next;
} QueueNode;

typedef struct Queue {
    QueueNode *front;
    QueueNode *rear;
} Queue;

void initQueue(Queue *q) {
    q->front = q->rear = NULL;
}

int isEmpty(Queue *q) {
    return q->front == NULL;
}

void enqueue(Queue *q, TreeNode *node) {
    QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode));
    newNode->node = node;
    newNode->next = NULL;
    if (isEmpty(q)) {
        q->front = q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

TreeNode *dequeue(Queue *q) {
    if (isEmpty(q)) {
        return NULL;
    }
    QueueNode *node = q->front;
    TreeNode *treeNode = node->node;
    q->front = node->next;
    if (q->front == NULL) {
        q->rear = NULL;
    }
    free(node);
    return treeNode;
}

TreeNode *createTree() {
    Queue q;
    initQueue(&q);
    int val;
    printf("请输入根节点的值：");
    scanf("%d", &val);
    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
    root->val = val;
    root->left = root->right = NULL;
    enqueue(&q, root);
    while (!isEmpty(&q)) {
        TreeNode *cur = dequeue(&q);
        int leftVal, rightVal;
        printf("请输入节点 %d 的左子节点和右子节点的值：", cur->val);
        scanf("%d%d", &leftVal, &rightVal);
        if (leftVal != -1) {
            TreeNode *left = (TreeNode *)malloc(sizeof(TreeNode));
            left->val = leftVal;
            left->left = left->right = NULL;
            cur->left = left;
            enqueue(&q, left);
        } else {
            cur->left = NULL;
        }
        if (rightVal != -1) {
            TreeNode *right = (TreeNode *)malloc(sizeof(TreeNode));
            right->val = rightVal;
            right->left = right->right = NULL;
            cur->right = right;
            enqueue(&q, right);
        } else {
            cur->right = NULL;
        }
    }
    return root;
}

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

int main() {
    TreeNode *root = createTree();
    printf("先序遍历结果为：");
    printTree(root);
    printf("\n");
    return ;
}

### 回答2：
要用C语言写一个按层次遍历建立二叉树，可以采用队列的数据结构来实现。

首先，定义一个二叉树的节点结构，包括左孩子指针、右孩子指针和节点值。

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

然后，定义一个队列结构，用于辅助层次遍历建立二叉树。

typedef struct QueueNode {
    struct TreeNode* node;
    struct QueueNode* next;
} QueueNode;

typedef struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
} Queue;

接下来，实现按层次遍历建立二叉树的函数。

TreeNode* buildTreeByLevel() {
    TreeNode* root = NULL;
    Queue* queue = createQueue(); // 创建队列
    int val;

    printf("请输入根节点的值：");
    scanf("%d", &val);
    if (val == -1) { // 输入-1表示空节点
        return NULL;
    }

    root = createTreeNode(val); // 创建根节点
    enqueue(queue, root);

    while (!isEmpty(queue)) {
        TreeNode* currNode = dequeue(queue);
        
        printf("请输入节点%d的左孩子的值：", currNode->val);
        scanf("%d", &val);
        if (val != -1) {
            TreeNode* leftChild = createTreeNode(val);
            currNode->left = leftChild;
            enqueue(queue, leftChild);
        }
        
        printf("请输入节点%d的右孩子的值：", currNode->val);
        scanf("%d", &val);
        if (val != -1) {
            TreeNode* rightChild = createTreeNode(val);
            currNode->right = rightChild;
            enqueue(queue, rightChild);
        }
    }

    destroyQueue(queue); // 销毁队列

    return root;
}

在该函数中，首先创建一个队列，用于存储待创建子节点的父节点。然后从输入中获取根节点的值，并根据值创建根节点。将根节点入队。

接下来，进入循环，逐个对队列中的节点进行处理。对于当前节点，首先根据输入的值创建左孩子节点，如果值为-1则表示左孩子为空节点。然后创建右孩子节点，同样如果值为-1则表示右孩子为空节点。将创建好的子节点入队。

循环结束后，即完成了按层次遍历建立二叉树的过程。

最后，销毁队列并返回建立好的二叉树的根节点。

需要注意的是，上述示例中的`createQueue()`、`enqueue()`、`dequeue()`、`createTreeNode()`、`isEmpty()`和`destroyQueue()`函数需要根据实际情况进行实现。

### 回答3：
以下是用C语言编写的按层次遍历建立二叉树的代码实现：

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

// 定义二叉树的结构
typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

// 创建一个新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 按层次遍历建立二叉树
Node* buildBinaryTree(int arr[], int size) {
    if (size <= 0) {
        return NULL;
    }

    Node* root = createNode(arr[0]);
    Node** queue = (Node**)malloc(sizeof(Node*) * size);
    queue[0] = root;

    int front = 0;
    int rear = 1;
    int i = 1;

    while (i < size) {
        Node* currNode = queue[front];
        Node* leftNode = createNode(arr[i]);
        currNode->left = leftNode;
        queue[rear++] = leftNode;
        i++;

        if (i >= size) {
            break;
        }

        Node* rightNode = createNode(arr[i]);
        currNode->right = rightNode;
        queue[rear++] = rightNode;
        i++;

        front++;
    }

    free(queue);
    return root;
}

// 打印二叉树（按层次遍历）
void printBinaryTree(Node* root) {
    if (root == NULL) {
        return;
    }

    Node** queue = (Node**)malloc(sizeof(Node*) * 100);
    int front = 0;
    int rear = 1;

    queue[0] = root;
    while (front < rear) {
        Node* currNode = queue[front];
        printf("%d ", currNode->data);

        if (currNode->left != NULL) {
            queue[rear++] = currNode->left;
        }

        if (currNode->right != NULL) {
            queue[rear++] = currNode->right;
        }

        front++;
    }

    free(queue);
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int size = sizeof(arr) / sizeof(arr[0]);

    Node* root = buildBinaryTree(arr, size);

    printf("按层次遍历建立的二叉树为：\n");
    printBinaryTree(root);

    return 0;
}

以上代码实现了按层次遍历建立二叉树，并可以通过打印输出按层次遍历的结果。首先定义了二叉树的结构 `Node`，包含数据域 `data` 以及左右子节点指针。然后通过 `createNode` 函数创建一个新节点，将传入的数据保存在节点中。`buildBinaryTree` 函数根据传入的整型数组和大小，利用队列实现按层次遍历的方式逐个添加节点，并连接为二叉树。`printBinaryTree` 函数利用队列按层次遍历打印二叉树的节点数据。最后在主函数中调用 `buildBinaryTree` 函数创建二叉树，再调用 `printBinaryTree` 函数打印建立的二叉树。