二叉树——初解

最新推荐文章于 2024-07-10 22:41:59 发布
最新推荐文章于 2024-07-10 22:41:59 发布
阅读量989 收藏 23
点赞数 28
文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34434522/article/details/138823452
版权

二叉树

树

树的概念

在计算机科学中，树（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;
}
深思慎考
关注
  • 28
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
算法第六期——DFS初入门(深度优先搜索)(Python)
荷叶田田的博客
12-30 6835
深度优先搜索算法 （ DFS ）是一种用于遍历或搜索 树 或 图 的 算法 。这个算法会尽可能深的搜索树的分支。. 当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。.如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。这种算法不会根据图的结构等信息调整执行策略
数据结构——排序
XSES_yasuoman的博客
09-15 237
啊！！！我好慢啊
五.二叉树——习题解
weixin_43811173的博客
08-18 261
文章目录一.递归1带返回值2.带参数deep3.三种遍历变体4.叶操作 一.递归 1带返回值 1.求高度——递归返回型，返回一个int值。 int Depth(BiTree T) { if (T==NULL) return 0; else return Depth(T->lchild) > Depth(T->rchild) ? Depth(T->lchild)+1 : Depth(T->rchild)+1; //return T == NULL ? 0 : De
二叉树——新二叉树(洛谷 P1305)
2401_83916435的博客
04-10 386
小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点， 本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。“刷”完本书后，你就是“题王”!
算法初解
weixin_44650011的博客
03-10 524
算法初解 之前曾经写过数学基础之函数增长与复杂性分类，但是主要是基于理论性知识，这篇博客会更侧重于具体的实例和复杂度的计算细节。 1、算法的定义 算法（AlgorithmAlgorithmAlgorithm），是针对给定问题的求解过程的规范性描述，是一系列用于求解问题的指令，算法本质上就是解决问题的方案，但是需要严格按照要求进行指令化。 置言之，以0或多个量作为输入，该算法能够在有限时间内执行完毕...
牛客网——选择题之解
Tough_dxx的博客
02-23 1230
1、在最好情况下，下列排序算法中 排序算法时间复杂度最低的是。 题解：https://blog.csdn.net/qq_29720657/article/details/78399558 2、串中任意个字符组成的子序列称为该串的子串。 题解：该题目是错误的，并且错在任意，对于给定的一个字符串来说，而它的子串是需要连续的，而并不是任意的。 3、设以下c语句中，对数组...
数据结构与算法之美笔记——树与二叉树
Cloneable的博客
08-11 360
摘要: 树是一种非线性表结构，多用链表的方式存储，也可使用数组存储，以节点为数据存储单元，节点的链接表示父子关系，二叉树是树的其中一种，一个父节点最多可以有两个子节点，遍历节点的时间复杂度为 O(n)O(n)O(n)。 树（Tree） 树长什么样 这种数据结构称为树，那一定和现实中的树存在着某些联系。首先我们来回忆一下现实中的树是什么模样，树都由根长起，然后分叉为枝丫，枝丫顶端生长出叶子，数据...
二叉树漫游——编程技术与技巧总结（上）：递归技术
瀞心：软件人生
03-19 1992
二叉树漫游——编程技术与技巧总结（上）：递归技术               本系列分三篇文章，分别对二叉树编程中的常用技术和技巧进行了总结。第一篇是关于二叉树编程的递归技术的；第二篇讨论如何将递归程序转化为非递归程序；第三篇讨论二叉树编程的其它方法和技术。
数据结构笔记——自用
weixin_45609535的博客
09-14 547
学习笔记，快速检索
最优二叉树——哈夫曼树.doc
07-11
树结构的特点是：它的每一个结点都可以有不止一个直接后继，除根结点外的所有结点都有且只有一个直接前趋。
二叉树——替罪羊树.ppt
11-07
1 引入替罪羊树的目的 2 替罪羊树的定义 3 替罪羊树的基本操作: 插入 删除 查询
数据结构树和二叉树——树
06-19
本节将深入探讨树的基本概念、二叉树、遍历、线索二叉树、树与森林的关系以及哈夫曼树。 6.1 树的定义和基本术语 树是由n个（n>=1）节点组成的有限集合，其中有一个特定的节点称为根节点，其余节点被分成m（m>=0）...
二叉树——双亲树
01-02
二叉树是一种特殊的树结构，每个节点最多只有两个子节点，通常分为左子节点和右子节点。在数据结构领域，二叉树因其高效的查找、插入和删除操作，被广泛应用于计算机科学的各种算法中。本程序关注的是双亲树，这是一...
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
7.10飞书一面面经
最新发布
东篱君的博客
07-10 459
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
MySQL空间索引
你的指尖有改变世界的力量
07-10 177
空间类型是建立在空间类型字段上的。
JDBC (基础)
weixin_51644244的博客
07-07 372
思考: java和sql是两种不同的编程语言。翻译程序---每个数据库厂商都提高了翻译软件-- -打包jar。---我们的java代码引入jar就可完成与数据库的沟通。Java ：OOP 面向对象的编程对象。SQL： 结构化查询语言。
数据库原理之并发控制的基本概念
m0_75262255的博客
07-06 1116
并发控制的简单介绍。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值