二叉树静态实现的示例代码

使用指针对于初学者容易出现很多困惑

下面是一个完整的二叉树静态实现的示例代码，包括初始化、插入节点、各种遍历方法以及一些辅助函数。

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

#define MAX_SIZE 100

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

struct TreeNode tree[MAX_SIZE];

int queue[MAX_SIZE];
int front = -1, rear = -1;

// 初始化二叉树
void init() {
    for (int i = 0; i < MAX_SIZE; i++) {
        tree[i].val = 0;
        tree[i].left = -1;
        tree[i].right = -1;
    }
}

// 插入节点
int insert(int val) {
    int i = 0;
    while (tree[i].val != 0 && i < MAX_SIZE) {
        if (val < tree[i].val) {
            if (tree[i].left == -1) {
                break;
            }
            i = tree[i].left;
        } else if (val > tree[i].val) {
            if (tree[i].right == -1) {
                break;
            }
            i = tree[i].right;
        } else {
            return -1; // 节点已存在
        }
    }
    if (tree[i].val == val) {
        return -1; // 节点已存在
    }
    if (i == MAX_SIZE) {
        return -2; // 数组已满
    }
    tree[i].val = val;
    tree[i].left = -1;
    tree[i].right = -1;
    return 0;
}

// 前序遍历
void preorder(int i) {
    if (i == -1) {
        return;
    }
    printf("%d ", tree[i].val);
    preorder(tree[i].left);
    preorder(tree[i].right);
}

// 中序遍历
void inorder(int i) {
    if (i == -1) {
        return;
    }
    inorder(tree[i].left);
    printf("%d ", tree[i].val);
    inorder(tree[i].right);
}

// 后序遍历
void postorder(int i) {
    if (i == -1) {
        return;
    }
    postorder(tree[i].left);
    postorder(tree[i].right);
    printf("%d ", tree[i].val);
}

// 层序遍历
void levelorder(int root) {
    if (root == -1) {
        return;
    }
    front = -1;
    rear = -1;
    queue[++rear] = root;
    while (front < rear) {
        int i = queue[++front];
        printf("%d ", tree[i].val);
        if (tree[i].left != -1) {
            queue[++rear] = tree[i].left;
        }
        if (tree[i].right != -1) {
            queue[++rear] = tree[i].right;
        }
    }
}

// 获取节点数量
int get_node_count() {
    int count = 0;
    for (int i = 0; i < MAX_SIZE; i++) {
        if (tree[i].val != 0) {
            count++;
        }
    }
    return count;
}

// 获取树的深度
int get_tree_depth(int i) {
    if (i == -1) {
        return 0;
    }
    int left_depth = get_tree_depth(tree[i].left);
    int right_depth = get_tree_depth(tree[i].right);
    return (left_depth > right_depth) ? left_depth + 1 : right_depth + 1;
}

int main() {
    init();
    insert(5);
    insert(3);
    insert(7);
    insert(1);
    insert(4);
    insert(6);
    insert(8);
    printf("Preorder traversal:\n");
    preorder(0);
    printf("\n");
    printf("Inorder traversal:\n");
    inorder(0);
    printf("\n");
    printf("Postorder traversal:\n");
    postorder(0);
    printf("\n");
    printf("Levelorder traversal:\n");
    levelorder(0);
    printf("\n");
    printf("Node count: %d\n", get_node_count());
    printf("Tree depth: %d\n", get_tree_depth(0));
    return 0;
}

输出结果

Preorder traversal:
5 3 1 4 7 6 8 
Inorder traversal:
1 3 4 5 6 7 8 
Postorder traversal:
1 4 3 6 8 7 5 
Levelorder traversal:
5 3 7 1 4 6 8 
Node count: 7
Tree depth: 3

顺便一提静态实现二叉树的好处在于：

1. 内存占用少：由于数组是在编译时就分配好内存的，因此不会像动态实现那样需要额外的空间来存储指针，从而可以减少内存占用。

2. 访问速度快：由于数组中的元素是连续存储的，因此访问元素的速度比指针访问要快。同时，对于一个二叉树而言，其节点的访问是有序的，因此可以充分利用 CPU 的缓存，从而提高访问速度。

3. 实现简单：相对于动态实现，静态实现的实现难度较小，不需要考虑内存管理等问题，因此代码相对简单。

4. 方便序列化和持久化：由于静态实现二叉树的所有节点信息都存储在一个数组中，因此可以方便地将其序列化为一个二进制文件，或者存储到磁盘中。在需要的时候，可以读取文件或者从磁盘中加载数据，重建二叉树。这在某些应用场景中是非常方便的，例如数据库系统中的索引结构。

静态实现二叉树的坏处主要在于：

1. 无法动态调整大小：由于数组的大小在编译时就已经确定了，因此在运行时无法动态地调整大小。如果需要插入更多的节点，就必须重新创建一个更大的数组，并将原来的节点复制到新数组中。

2. 空间利用率低：由于数组的大小在编译时就已经确定了，因此在大多数情况下，数组的大小都会超过实际需要的大小。这样就会浪费一定的内存空间。

3. 插入和删除效率低：由于在静态实现中，每个节点都是一个数组元素，因此在插入或删除节点时，需要将其他节点在数组中的位置向前或向后移动，这样会导致操作的效率比较低。

4. 不支持多线程并发操作：由于数组是在编译时就分配好内存的，因此如果需要在多个线程之间共享一个静态实现的二叉树，就需要进行一定的同步控制，否则可能会导致不可预期的错误。