二叉树
- 树
- 树的概念
- 树的性质
- 二叉树
- 二叉树的概念
- 二叉树的性质
- 二叉树的实现方式
- 数组构建
- 左孩子右兄弟法构建
- 指针构建
树
树的概念
在计算机科学中，树（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;
}
