"Estructura de datos: árbol de implementación del lenguaje C (árbol)" implementa un árbol binario e incluye un recorrido previo, en orden y posterior al pedido

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

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

// 创建一个新的节点
struct TreeNode* new_node(int val) {
    struct TreeNode* node = (struct TreeNode*) malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 插入节点
struct TreeNode* insert_node(struct TreeNode* root, int val) {
    if (root == NULL) {
        root = new_node(val);
        return root;
    }
    if (val < root->val) {
        root->left = insert_node(root->left, val);
    } else {
        root->right = insert_node(root->right, val);
    }
    return root;
}

// 前序遍历
void preorder_traversal(struct TreeNode* root) {
    if (root != NULL) {
        printf("%d ", root->val);
        preorder_traversal(root->left);
        preorder_traversal(root->right);
    }
}

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

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

int main() {
    // 创建一个二叉树
    struct TreeNode* root = new_node(5);
    insert_node(root, 3);
    insert_node(root, 7);
    insert_node(root, 2);
    insert_node(root, 4);
    insert_node(root, 6);
    insert_node(root, 8);

    // 前序遍历二叉树并输出结果
    printf("前序遍历结果：");
    preorder_traversal(root);
    printf("\n");

    // 中序遍历二叉树并输出结果
    printf("中序遍历结果：");
    inorder_traversal(root);
    printf("\n");

    // 后序遍历二叉树并输出结果
    printf("后序遍历结果：");
    postorder_traversal(root);
    printf("\n");

    return 0;
}

En este ejemplo, primero definimos una TreeNodeestructura llamada struct para representar los nodos del árbol binario. También definimos funciones new_nodepara crear un nuevo nodo e inicializar su valor y punteros de nodos secundarios.

En insert_nodela función, implementamos la función de insertar nodos en el árbol binario. Si el árbol está vacío, creamos un nuevo nodo y lo devolvemos. Si el valor del nodo es más pequeño que el nodo raíz, se inserta en el subárbol izquierdo; de lo contrario, se inserta en el subárbol derecho.

En preorder_traversalla función, implementamos la función de atravesar el árbol binario en orden previo. Primero visitamos el nodo raíz, luego recorremos la izquierda

subárbol, y finalmente atravesar el subárbol derecho. En inorder_traversalla función, implementamos la función de atravesar el árbol binario en orden. Primero recorremos el subárbol izquierdo, luego visitamos el nodo raíz y finalmente recorremos el subárbol derecho. En postorder_traversalla función, implementamos la función de recorrido posterior al orden del árbol binario. Atravesamos primero el subárbol izquierdo, luego el subárbol derecho y finalmente visitamos el nodo raíz.

En mainla función, primero creamos un nuevo árbol binario e insertamos algunos nodos en él. Luego, llamamos a las funciones y respectivamente preorder_traversalpara inorder_traversalrealizar un postorder_traversalrecorrido previo, en orden y posterior al pedido en este árbol binario, y mostrar los resultados del recorrido.

Tenga en cuenta que el código anterior es solo un ejemplo simple para demostrar la implementación del árbol binario y el recorrido previo, en orden y posterior al pedido. De hecho, en aplicaciones prácticas, se deben considerar algunos factores adicionales, como el equilibrio del árbol binario, la eficiencia algorítmica de insertar y eliminar nodos, etc.