数据结构中用数组或队列实现树

原创已于 2025-06-09 22:39:32 修改 · 980 阅读

20 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

数据结构与算法分析

于 2025-06-09 22:38:31 首次发布

引言

树（Tree）是一种非线性数据结构，用于表示具有层次关系的数据。树由节点（Node）组成，每个节点可以有零个或多个子节点，但只能有一个父节点（根节点除外）。树的结构类似于现实生活中的树木，根节点位于顶部，子节点像树枝一样向下延伸。树广泛应用于文件系统、数据库索引、编译器的语法分析和算法设计等领域。

本文将详细介绍树数据结构的基本概念、类型、操作以及在C语言中的实现方式，重点关注二叉树和通用树。通过代码示例和分析，帮助初学者理解树的特性和应用。

树的定义与特性

树是一种非线性数据结构，具有以下特性：

根节点（Root）：树的顶部节点，没有父节点。
子节点（Children）：每个节点可以有零个或多个子节点。
父节点（Parent）：除根节点外的每个节点都有且只有一个父节点。
路径（Path）：从根节点到任何节点都存在唯一路径。
叶节点（Leaf）：没有子节点的节点。
子树（Subtree）：以某个节点为根的树。

树的结构可以用以下方式表示：

层次结构：树具有多个层次，根节点在第一层，子节点在下一层。
非线性：与数组、链表等线性结构不同，树允许每个节点有多个“下一个”节点。

树的应用包括：

文件系统：目录和文件形成树结构。
数据库：B树用于索引。
编译器：语法树表示源代码结构。
算法：如决策树、哈夫曼编码等。

树的操作

树支持以下基本操作：

插入（Insert）：将新节点添加到树中。
删除（Delete）：移除指定节点。
搜索（Search）：查找特定值的节点。
遍历（Traversal）：访问树中所有节点，常见方式包括：
- 先序遍历（Preorder）：根节点、左子树、右子树。
- 中序遍历（Inorder）：左子树、根节点、右子树。
- 后序遍历（Postorder）：左子树、右子树、根节点。

二叉树的实现

二叉树是树的一种特殊形式，每个节点最多有两个子节点（左子节点和右子节点）。在C语言中，我们可以使用结构体来表示二叉树的节点。

二叉树节点结构

typedef struct Node {
    int data;          // 节点数据
    struct Node* left; // 左子节点指针
    struct Node* right; // 右子节点指针
} Node;

创建新节点

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

二叉搜索树（BST）的插入

在BST中，插入操作需要维护搜索树的性质：左子树所有节点值小于根节点，右子树所有节点值大于根节点。

Node* insert(Node* root, int data) {
    if (root == NULL) {
        return createNode(data);
    }
    if (data < root->data) {
        root->left = insert(root->left, data);
    } else if (data > root->data) {
        root->right = insert(root->right, data);
    }
    return root;
}

二叉搜索树的搜索

搜索操作从根节点开始，根据节点值递归查找。

Node* search(Node* root, int data) {
    if (root == NULL || root->data == data) {
        return root;
    }
    if (data < root->data) {
        return search(root->left, data);
    } else {
        return search(root->right, data);
    }
}

二叉搜索树的删除

删除操作需要考虑三种情况：

节点无子节点（叶节点）。
节点有一个子节点。
节点有两个子节点（需要找到中序后继或前驱）。

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;
}

二叉树的遍历

二叉树的遍历有三种方式：

先序遍历（Preorder）：根、左、右。
中序遍历（Inorder）：左、根、右。
后序遍历（Postorder）：左、右、根。

void preorderTraversal(Node* root) {
    if (root != NULL) {
        printf("%d ", root->data);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}

void inorderTraversal(Node* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

void postorderTraversal(Node* root) {
    if (root != NULL) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        printf("%d ", root->data);
    }
}

通用树的实现

通用树允许每个节点有任意数量的子节点。我们可以使用一个固定大小的数组来存储子节点。

通用树节点结构

#define MAX_CHILDREN 10

typedef struct Node {
    int data;                  // 节点数据
    struct Node* children[MAX_CHILDREN]; // 子节点数组
    int numChildren;           // 子节点数量
} Node;

创建新节点

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->numChildren = 0;
    memset(newNode->children, 0, sizeof(newNode->children));
    return newNode;
}

添加子节点

int addChild(Node* parent, Node* child) {
    if (parent->numChildren >= MAX_CHILDREN) {
        return 0; // 无法添加更多子节点
    }
    parent->children[parent->numChildren] = child;
    parent->numChildren++;
    return 1;
}

通用树的遍历（先序遍历）

void preorderTraversalGeneral(Node* root) {
    if (root != NULL) {
        printf("%d ", root->data);
        for (int i = 0; i < root->numChildren; i++) {
            preorderTraversalGeneral(root->children[i]);
        }
    }
}