二叉树：
类型：
斜树：所有节点都只有在左子树或者右子树, （退化成了链表）

满二叉树：
二叉树中所有非叶子节点都是2， 且叶子节点都在同一个层次上

完全二叉树：
如果有一个二叉树与满二叉树前m个节点的结构相同， 这样的二叉树称为完全二叉树

二叉查找树 (BST) ：

定义：左边的节点树，比右边的节点树大
特点：

• 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
• 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
• 任意节点的左、右子树也分别为二叉查找树；
• 没有键值相等的节点
  

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct Node {
   
    int data;
    struct Node* left;
    struct Node* right;
} Node;
// 创建新的节点
Node* newNode(int data) {
   
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 插入节点
Node* insertNode(Node* node, int data) {
   
    if (node == NULL) {
   
        return newNode(data);
    }

    if (data < node->data) {
   
        node->left = insertNode(node->left, data);
    } else if (data > node->data) {
   
        node->right = insertNode(node->right, data);
    }

    return node;
}

// 查找节点
Node* searchNode(Node* root, int data) {
   
    if (root == NULL || root->data == data)
        return root;

    if (root->data < data)
        return searchNode(root->right, data);

    return searchNode(root->left, data);
}

// 修改节点
void modifyNode(Node* root, int oldData, int newData) {
   
    Node* node = searchNode(root, oldData);
    if (node != NULL) {
   
        node->data = newData;
    }
}

// 找到最小值节点
Node* minValueNode(Node* node) {
   
    Node* current = node;

    while (current && current->left != NULL)
        current = current->left;

    return current;
}

// 删除节点
Node* deleteNode(Node* root, int data) {
   
    if (root == NULL) return root;

    if (data < root->data)
        root->left = deleteNode(root->left, data);
    else if (data > root->data)
        root->right = deleteNode(root->right, data);
    else {
   
        if (root->left == NULL) {
   
            Node* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
   
            Node* temp = root->left;
            free(root);
            return temp;
        }

        Node* temp = minValueNode(root->right);

        root->data = temp->data;

        root->right = deleteNode(root->right, temp->data);
    }
    return root;
}
// 前序遍历
void preOrder(Node* root) {
   
    if (root != NULL) {
   
        cout << root->data << " ";  // 访问根节点
        preOrder(root->left);  // 递归遍历左子树
        preOrder(root->right);  // 递归遍历右子树
    }
}
// 中序遍历
void inOrder(Node* root) {
   
    if (root != NULL) {
   
        inOrder(root->left);  // 递归遍历左子树
        cout << root->data << " ";  // 访问根节点
        inOrder(root->right);  // 递归遍历右子树
    }
}
// 后序遍历
void postOrder(Node* root) {
   
    if (root != NULL) {
   
        postOrder(root->left);  // 递归遍历左子树
        postOrder(root->right);  // 递归遍历右子树
        cout << root->data << " ";  // 访问根节点
    }
}
int main() {
   
    Node* root = NULL;

    // 插入节点
    root = insertNode(root, 50);
    insertNode(root, 30);
    insertNode(root, 20);
    insertNode(root, 40);
    insertNode(root, 70);
    insertNode(root, 60);
    insertNode(root, 80);

    printf("先序遍历: ");
    preOrder(root);  // 前序遍历

    printf("\n");

    printf("中序遍历：");
    inOrder(root);  // 中序遍历

    printf("\n");

    printf("后序遍历：");
    postOrder(root);  // 后序遍历

    printf("\n");
    // 查找节点
    Node* found = searchNode(root, 70);
    if (found) {
   
        printf("Found node with data: %d\n", found->data);
    } else {
   
        printf("Node not found.\n");
    }

    // 修改节点
    modifyNode(root, 70, 75);

    // 再次查找节点
    found = searchNode(root, 75);
    if (found) {
   
        printf("Found node with data: %d\n", found->data);
    } else {
   
        printf("Node not found.\n");
    }

    // 删除节点
    root = deleteNode(root, 20);

    // 再次查找节点
    found = searchNode(root, 20);
    if