极简二叉树

二叉树是树形结构中最简单的一种，也是树形内容的关键部分。

二叉树由一系列节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。每个节点包含一个值和两个指向其子节点的指针。

以下为一个简单的二叉树结构定义，每个节点存储一个整数：

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

二叉树的遍历方式包括先序遍历、中序遍历和后序遍历。这些遍历方式描述了访问二叉树中节点的特定顺序。

1. 先序遍历（Preorder Traversal）：先访问根节点，然后遍历左子树，最后遍历右子树。在具体实现时，首先访问当前节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。示例代码：

void preorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->val);  // 先访问根节点
    preorderTraversal(root->left);  // 遍历左子树
    preorderTraversal(root->right);  // 遍历右子树
}

2. 中序遍历（Inorder Traversal）： 首先遍历左子树，然后访问根节点，最后遍历右子树。在具体实现时，首先递归地中序遍历左子树，然后访问当前节点，最后递归地中序遍历右子树。示例代码：

void inorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left);  // 遍历左子树
    printf("%d ", root->val);  // 访问根节点
    inorderTraversal(root->right);  // 遍历右子树
}

3. 后序遍历（Postorder Traversal）： 首先遍历左子树，然后遍历右子树，最后访问根节点。在具体实现时，首先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问当前节点。示例代码：

void postorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);  // 遍历左子树
    postorderTraversal(root->right);  // 遍历右子树
    printf("%d ", root->val);  // 访问根节点
}

可以从键盘输入数据创建二叉树，也可以用一个整数数组来初始化二叉树，以下为完整示例代码：

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

//树节点
struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 建立二叉树
struct TreeNode* createNode(struct TreeNode* parent, int isLeft) {
    if (parent == NULL)
        printf("请输入二叉树的根节点：");
    else
        printf("请输入%d的%s子节点：", parent -> val, isLeft ? "左" : "右");

    int value;
    scanf("%d", &value);
    if (value == -1) {
        return NULL;
    }
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = value;
    node->left = createNode(node, 1);
    node->right = createNode(node, 0);
    return node;
}

// 根据数组创建二叉树
struct TreeNode* createNodeByValues(int values[], int len, int *index) {
    if (values[*index] == -1) {
        (*index)++;
        return NULL;
    }
    if (*index >= len) {
        return NULL;
    }
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = values[(*index)++];
    node->left = createNodeByValues(values, len, index);
    node->right = createNodeByValues(values, len, index);
    return node;
}

// 先序遍历
void preorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->val);  // 先访问根节点
    preorderTraversal(root->left);  // 遍历左子树
    preorderTraversal(root->right);  // 遍历右子树
}

// 中序遍历
void inorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left);  // 遍历左子树
    printf("%d ", root->val);  // 访问根节点
    inorderTraversal(root->right);  // 遍历右子树
}

// 后序遍历
void postorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);  // 遍历左子树
    postorderTraversal(root->right);  // 遍历右子树
    printf("%d ", root->val);  // 访问根节点
}

void freeTree(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    if (root->left != NULL) {
        freeTree(root->left);
    }
    if (root->right != NULL) {
        freeTree(root->right);
    }
}

int main() {
    // 输入数据创建二叉树
    struct TreeNode* root = createNode(NULL, 0);

    /*int values[] = {1, 2, 3, -1, 4, -1, -1, 5, -1, -1, 6, -1, -1};
    int len = sizeof(values) / sizeof(int);
    int index = 0;
    // 数组初始化二叉树
    struct TreeNode* root = createNodeByValues(values, len, &index);*/

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

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

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

    // 释放树
    freeTree(root);

    return 0;
}