实现二叉树的构造以及四种遍历算法的完整c语言代码

### 回答1：
以下是二叉树的构造及四种遍历算法的完整C语言代码：

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

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

// 创建新节点
Node* create_node(int data) {
    Node *new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->left = NULL;
    new_node->right = NULL;
    return new_node;
}

// 插入节点
Node* insert_node(Node *root, int data) {
    if (root == NULL) {
        root = create_node(data);
    } else if (data <= root->data) {
        root->left = insert_node(root->left, data);
    } else {
        root->right = insert_node(root->right, data);
    }
    return root;
}

// 先序遍历
void preorder_traversal(Node *root) {
    if (root != NULL) {
        printf("%d ", root->data);
        preorder_traversal(root->left);
        preorder_traversal(root->right);
    }
}

// 中序遍历
void inorder_traversal(Node *root) {
    if (root != NULL) {
        inorder_traversal(root->left);
        printf("%d ", root->data);
        inorder_traversal(root->right);
    }
}

// 后序遍历
void postorder_traversal(Node *root) {
    if (root != NULL) {
        postorder_traversal(root->left);
        postorder_traversal(root->right);
        printf("%d ", root->data);
    }
}

// 层序遍历
void levelorder_traversal(Node *root) {
    if (root == NULL) return;
    Node *queue[100];
    int front = 0, rear = 0;
    queue[rear++] = root;
    while (front < rear) {
        Node *current = queue[front++];
        printf("%d ", current->data);
        if (current->left != NULL) {
            queue[rear++] = current->left;
        }
        if (current->right != NULL) {
            queue[rear++] = current->right;
        }
    }
}

int main() {
    Node *root = NULL;
    root = insert_node(root, 8);
    root = insert_node(root, 3);
    root = insert_node(root, 10);
    root = insert_node(root, 1);
    root = insert_node(root, 6);
    root = insert_node(root, 14);
    root = insert_node(root, 4);
    root = insert_node(root, 7);
    root = insert_node(root, 13);
    printf("先序遍历: ");
    preorder_traversal(root);
    printf("\n中序遍历: ");
    inorder_traversal(root);
    printf("\n后序遍历: ");
    postorder_traversal(root);
    printf("\n层序遍历: ");
    levelorder_traversal(root);
    printf("\n");
    return 0;
}

上述代码创建了一个二叉树，并实现了四种遍历算法：先序遍历、中序遍历、后序遍历、层序遍历。其中，先序遍历、中序遍历和后序遍历都是递归实现，而层序遍历使用了队列。

### 回答2：
以下是二叉树的构造和四种遍历算法的完整C语言代码：

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

// 定义二叉树结点
typedef struct TreeNode {
int data;
struct TreeNode* left;
struct TreeNode* right;
} TreeNode;

// 创建二叉树结点
TreeNode* createTreeNode(int data) {
TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}

// 构造二叉树
void constructBinaryTree(TreeNode** root, int data) {
if (*root == NULL) {
*root = createTreeNode(data);
} else {
// 判断插入的结点应该在左子树还是右子树
if (data < (*root)->data) {
constructBinaryTree(&((*root)->left), data);
} else {
constructBinaryTree(&((*root)->right), data);
}
}
}

// 先序遍历
void preorderTraversal(TreeNode* root) {
if (root != NULL) {
printf("%d ", root->data);
preorderTraversal(root->left);
preorderTraversal(root->right);
}
}

// 中序遍历
void inorderTraversal(TreeNode* root) {
if (root != NULL) {
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}
}

// 后序遍历
void postorderTraversal(TreeNode* root) {
if (root != NULL) {
postorderTraversal(root->left);
postorderTraversal(root->right);
printf("%d ", root->data);
}
}

// 层序遍历
void levelorderTraversal(TreeNode* root) {
if (root == NULL) {
return;
}
TreeNode* queue[100]; // 使用队列保存结点
int front = 0, rear = 0;
queue[rear++] = root;

while (front < rear) {
TreeNode* current = queue[front++];
printf("%d ", current->data);

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

int main() {
TreeNode* root = NULL;

// 构造二叉树
constructBinaryTree(&root, 50);
constructBinaryTree(&root, 30);
constructBinaryTree(&root, 80);
constructBinaryTree(&root, 10);
constructBinaryTree(&root, 40);
constructBinaryTree(&root, 60);
constructBinaryTree(&root, 90);

printf("先序遍历：");
preorderTraversal(root);
printf("\n");

printf("中序遍历：");
inorderTraversal(root);
printf("\n");

printf("后序遍历：");
postorderTraversal(root);
printf("\n");

printf("层序遍历：");
levelorderTraversal(root);
printf("\n");

return 0;
}

这段代码会构造一个二叉树，并分别进行先序、中序、后序和层序遍历，然后输出结果。

### 回答3：
二叉树的构造以及四种遍历算法的完整C语言代码如下：

1. 二叉树的构造：

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

// 定义二叉树节点结构
struct TreeNode {
int val;
struct TreeNode* left;
struct TreeNode* right;
};

// 创建新的节点
// 参数：节点值
// 返回值：新节点的指针
struct TreeNode* createNode(int val) {
struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
if (newNode == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
}

newNode->val = val;
newNode->left = NULL;
newNode->right = NULL;

return newNode;
}

// 构造二叉树
// 参数：节点值数组、节点个数
// 返回值：根节点的指针
struct TreeNode* buildTree(int* array, int size) {
struct TreeNode** nodes = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * size);
if (nodes == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
}

// 初始化节点指针数组
for (int i = 0; i < size; i++) {
nodes[i] = createNode(array[i]);
}

// 构建二叉树
for (int i = 0; i < size / 2; i++) {
if (2 * i + 1 < size) {
nodes[i]->left = nodes[2 * i + 1];
}
if (2 * i + 2 < size) {
nodes[i]->right = nodes[2 * i + 2];
}
}

return nodes[0];
}

2. 前序遍历：

// 前序遍历
// 参数：二叉树根节点的指针
void preorderTraversal(struct TreeNode* root) {
if (root == NULL) {
return;
}

printf("%d ", root->val); // 输出节点的值
preorderTraversal(root->left); // 遍历左子树
preorderTraversal(root->right); // 遍历右子树
}

3. 中序遍历：

// 中序遍历
// 参数：二叉树根节点的指针
void inorderTraversal(struct TreeNode* root) {
if (root == NULL) {
return;
}

inorderTraversal(root->left); // 遍历左子树
printf("%d ", root->val); // 输出节点的值
inorderTraversal(root->right); // 遍历右子树
}

4. 后序遍历：

// 后序遍历
// 参数：二叉树根节点的指针
void postorderTraversal(struct TreeNode* root) {
if (root == NULL) {
return;
}

postorderTraversal(root->left); // 遍历左子树
postorderTraversal(root->right); // 遍历右子树
printf("%d ", root->val); // 输出节点的值
}

使用示例：

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

// 构造二叉树
struct TreeNode* root = buildTree(array, size);

// 前序遍历
printf("前序遍历结果：");
preorderTraversal(root);
printf("\n");

// 中序遍历
printf("中序遍历结果：");
inorderTraversal(root);
printf("\n");

// 后序遍历
printf("后序遍历结果：");
postorderTraversal(root);
printf("\n");

return 0;
}