树

树的概念

在计算机科学中，树（Tree）是一种重要的非线性数据结构，它由若干节点（Node）组成，并且这些节点之间以边（Edge）连接起来。树的节点可以有零个或多个子节点，但每个节点最多只能有一个父节点，其中一个节点被称为根节点（Root Node），没有父节点。除了根节点外，每个节点都有且仅有一个父节点，使得整个结构呈现出类似于自然界中树的形状，因此得名。

树的性质

树的基本概念包括：

• 节点（Node）：树中的基本元素，每个节点包含一个数据元素和指向其子节点的指针。

• 根节点（Root Node）：树的顶端节点，它是树的起始点，没有父节点。

• 父节点（Parent Node）：除了根节点外，每个节点都有一个父节点。

• 子节点（Child Node）：一个节点的直接下级节点称为其子节点。

• 叶子节点（Leaf Node）：没有子节点的节点称为叶子节点或终端节点。

• 路径（Path）：从树中一个节点到另一个节点的序列，沿着边连接而形成。

• 层级（Level）：根节点的层级为0，其直接子节点的层级为1，依次类推。

• 深度（Depth）：节点所在的层数称为节点的深度，一般根节点的深度为0，依次递增。

• 高度（Height）：树中节点的最大深度称为树的高度。在一棵高度为h的树中，根节点的高度为h，叶子节点的高度为0。

• 子树（Subtree）：树中的任意节点及其所有子孙节点构成的树称为原树的子树。

• 森林（Forest）：由m（m>=0）棵互不相交的树组成的集合称为森林。

二叉树

二叉树的概念

二叉树是一种常见的树形数据结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的结构使得它在计算机科学领域中被广泛应用，例如在搜索算法、排序算法、编译器设计和网络路由中。

二叉树的性质

以下是二叉树的一些重要概念和特性：

• 节点（Node）：二叉树中的每个元素称为节点。每个节点包含一个数据元素和指向其左子节点和右子节点的指针。

• 根节点（Root Node）：二叉树的顶端节点称为根节点，它是树的起始点。

• 叶子节点（Leaf Node）：没有子节点的节点称为叶子节点，也叫终端节点。

• 父节点（Parent Node）、子节点（Child Node）：一个节点的直接上级节点称为其父节点，而直接下级节点称为其子节点。

• 深度（Depth）：节点所在的层数称为节点的深度，根节点的深度为0，依次递增。

• 高度（Height）：树中节点的最大深度称为树的高度。在一棵高度为h的二叉树中，叶子节点的高度为h，而根节点的高度为0。

• 满二叉树（Full Binary Tree）：除了叶子节点外，每个节点都有两个子节点的二叉树称为满二叉树。

• 完全二叉树（Complete Binary Tree）：除了最后一层，其他层的节点都是满的，并且最后一层的节点都集中在左边，这样的二叉树称为完全二叉树。

• 二叉搜索树（Binary Search Tree，BST）：一种特殊的二叉树，其中每个节点的值大于其左子树中的所有节点的值，小于其右子树中的所有节点的值。这个特性使得BST能够快速地进行查找、插入和删除操作。

• 遍历（Traversal）：遍历是指按照一定的顺序访问树中的每个节点。常见的二叉树遍历方式包括前序遍历（Pre-order）、中序遍历（In-order）、后序遍历（Post-order）和层序遍历（Level-order）。

一颗满二叉树，完全二叉树：

二叉树的实现方式

数组构建

1，构建二叉树的一种简单方法是通过数组表示树的结构。数组中的每个元素代表二叉树中的一个节点，并且通过数组索引之间的关系来表示节点之间的父子关系。

假设我们有一个数组 arr 表示二叉树的节点，其中根节点位于索引 0 处。对于任意索引 i，其左子节点位于 2*i + 1 处，右子节点位于 2*i + 2 处。如果某个子节点不存在，则其对应的位置为 nullptr 或特殊值。

下面是一个简单的示例代码，演示如何通过数组构建二叉树：

#include <iostream>
#include <vector>struct TreeNode {int data;TreeNode* left;TreeNode* right;TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};class BinaryTree {
private:std::vector<TreeNode*> nodes;public:BinaryTree() {}void buildTree(std::vector<int>& arr) {// 创建节点并将其放入节点数组中for (int val : arr) {nodes.push_back(new TreeNode(val));}// 构建树的结构for (int i = 0; i < arr.size(); ++i) {if (2 * i + 1 < arr.size()) {nodes[i]->left = nodes[2 * i + 1];}if (2 * i + 2 < arr.size()) {nodes[i]->right = nodes[2 * i + 2];}}}// 释放节点内存void clear() {for (TreeNode* node : nodes) {delete node;}nodes.clear();}// 前序遍历void preorder(TreeNode* node) {if (node == nullptr) return;std::cout << node->data << " ";preorder(node->left);preorder(node->right);}
};int main() {std::vector<int> arr = {1, 2, 3, 4, 5, 6, 7};BinaryTree tree;tree.buildTree(arr);tree.preorder(arr[0]); // 以根节点开始前序遍历tree.clear(); // 清除内存return 0;
}

在这个示例中，我们首先创建了表示二叉树的数组 arr，然后通过 buildTree 函数构建了二叉树的结构，并且通过前序遍历验证了构建的结果。最后，在程序结束时调用 clear 函数释放了动态分配的内存。

左孩子右兄弟法构建

左孩子右兄弟法（Left Child Right Sibling representation）是一种二叉树的表示方法，它将二叉树表示为多叉树的形式，每个节点有两个指针，一个指向其左子节点，另一个指向其右兄弟节点。

类似如此：

下面是一个简单的示例代码，演示如何通过左孩子右兄弟法构建二叉树：

#include <iostream>struct TreeNode {int data;TreeNode* leftChild;TreeNode* rightSibling;TreeNode(int val) : data(val), leftChild(nullptr), rightSibling(nullptr) {}
};class BinaryTree {
private:TreeNode* root;public:BinaryTree() : root(nullptr) {}// 插入节点void insert(int parentVal, int val) {if (root == nullptr) {root = new TreeNode(parentVal);root->leftChild = new TreeNode(val);} else {TreeNode* parent = findNode(root, parentVal);if (parent != nullptr) {if (parent->leftChild == nullptr) {parent->leftChild = new TreeNode(val);} else {TreeNode* sibling = parent->leftChild;while (sibling->rightSibling != nullptr) {sibling = sibling->rightSibling;}sibling->rightSibling = new TreeNode(val);}} else {std::cout << "Parent node not found." << std::endl;}}}// 查找节点TreeNode* findNode(TreeNode* node, int val) {if (node == nullptr) return nullptr;if (node->data == val) return node;// 递归在左子树中查找TreeNode* foundNode = findNode(node->leftChild, val);if (foundNode != nullptr) return foundNode;// 递归在右兄弟节点中查找return findNode(node->rightSibling, val);}// 前序遍历void preorder(TreeNode* node) {if (node == nullptr) return;std::cout << node->data << " ";preorder(node->leftChild);preorder(node->rightSibling);}
};int main() {BinaryTree tree;// 构建二叉树tree.insert(1, 2);tree.insert(1, 3);tree.insert(1, 4);tree.insert(2, 5);tree.insert(2, 6);tree.insert(3, 7);// 前序遍历tree.preorder(tree.getRoot());return 0;
}

在这个示例中，我们定义了 TreeNode 结构体来表示树节点，其中包含一个指向左子节点的指针 leftChild 和一个指向右兄弟节点的指针 rightSibling。然后，通过 BinaryTree 类的 insert 方法插入节点，并且通过前序遍历验证了构建的结果。

指针构建

1，使用链表建立二叉树通常有两种常见的方式：链表嵌套节点或者使用指针连接节点。以下是两种方法的示例：

• 方法一：链表嵌套节点

#include <iostream>struct TreeNode {int data;TreeNode* left;TreeNode* right;TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};// 链表节点
struct ListNode {int data;ListNode* next;ListNode(int val) : data(val), next(nullptr) {}
};class BinaryTree {
private:TreeNode* root;// 使用递归构建二叉树TreeNode* buildTree(ListNode*& head) {if (head == nullptr) return nullptr;// 从链表中取出节点值int val = head->data;head = head->next;// 构建当前节点TreeNode* node = new TreeNode(val);// 递归构建左子树和右子树node->left = buildTree(head);node->right = buildTree(head);return node;}public:BinaryTree() : root(nullptr) {}// 从链表构建二叉树void buildFromList(ListNode* head) {root = buildTree(head);}// 前序遍历void preorder(TreeNode* node) {if (node == nullptr) return;std::cout << node->data << " ";preorder(node->left);preorder(node->right);}// 获取根节点TreeNode* getRoot() {return root;}
};int main() {// 构建链表表示的二叉树ListNode* head = new ListNode(1);head->next = new ListNode(2);head->next->next = new ListNode(3);head->next->next->next = new ListNode(4);head->next->next->next->next = new ListNode(5);BinaryTree tree;tree.buildFromList(head);// 前序遍历tree.preorder(tree.getRoot());return 0;
}

• 方法二：使用指针连接节点

#include <iostream>struct TreeNode {int data;TreeNode* left;TreeNode* right;TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};class BinaryTree {
private:TreeNode* root;// 使用递归构建二叉树TreeNode* buildTree(int* arr, int& index, int size) {if (index >= size || arr[index] == -1) {index++;return nullptr;}// 构建当前节点TreeNode* node = new TreeNode(arr[index]);index++;// 构建左子树和右子树node->left = buildTree(arr, index, size);node->right = buildTree(arr, index, size);return node;}public:BinaryTree() : root(nullptr) {}// 从数组构建二叉树void buildFromArray(int* arr, int size) {int index = 0;root = buildTree(arr, index, size);}// 前序遍历void preorder(TreeNode* node) {if (node == nullptr) return;std::cout << node->data << " ";preorder(node->left);preorder(node->right);}// 获取根节点TreeNode* getRoot() {return root;}
};int main() {// 构建数组表示的二叉树int arr[] = {1, 2, 4, -1, -1, -1, 3, -1, -1};int size = sizeof(arr) / sizeof(arr[0]);BinaryTree tree;tree.buildFromArray(arr, size);// 前序遍历tree.preorder(tree.getRoot());return 0;
}