二叉树的相关性质及其前中后层序遍历实现

最新推荐文章于 2024-06-26 13:06:42 发布

子木呀

最新推荐文章于 2024-06-26 13:06:42 发布

阅读量422

点赞数

分类专栏： C/C++、嵌入式知识整理文章标签：数据结构二叉树遍历前序遍历中序遍历层序遍历

本文链接：https://blog.csdn.net/qq_41687938/article/details/115656567

版权

C/C++、嵌入式知识整理专栏收录该内容

111 篇文章 46 订阅

订阅专栏

写在前面：

本文前面部分介绍相关概念，后面部分是程序。

点击下面链接查看更多！

点击此处发现更多

一、二叉树的概念

1.1 相关术语

①结点：包含一个数据元素及若干指向子树分支的信息。

②结点的度：一个结点拥有子树的数目称为结点的度。

③叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。

④分支结点：也称为非终端结点，度不为零的结点称为非终端结点。

⑤树的度：树中所有结点的度的最大值。

⑥结点的层次：从根结点开始，假设根结点为第1层，根结点的子节点为第2层，依此类推，如果某一个结点位于第L层，则其子节点位于第L+1层。

⑦树的深度：也称为树的高度，树中所有结点的层次最大值称为树的深度。

⑧有序树：如果树中各棵子树的次序是有先后次序，则称该树为有序树。

⑨无序树：如果树中各棵子树的次序没有先后次序，则称该树为无序树。

⑩森林：由m（m≥0）棵互不相交的树构成一片森林。如果把一棵非空的树的根结点删除，则该树就变成了一片森林，森林中的树由原来根结点的各棵子树构成。

1.2 相关性质

性质1：二叉树的第i层上至多有 $2^{i}-1\left ( i\geqslant 1 \right )$ 个节点。

性质2：深度为h的二叉树中至多含有 $2^{h}-1$ 个节点。

性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1。

性质4：具有n个节点的完全二叉树深为 $log_{2}x+1$ （其中x表示不大于n的最大整数）。

性质5：若对一棵有n个节点的完全二叉树进行顺序编号（1≤i≤n），那么，对于编号为i（i≥1）的节点：

当i=1时，该节点为根，它无双亲节点。

当i>1时，该节点的双亲节点的编号为i/2 。

若2i≤n，则有编号为2i的左节点，否则没有左节点。

若2i+1≤n，则有编号为2i+1的右节点，否则没有右节点。

1.3 二叉树类型

普通二叉树、完全二叉树、满二叉树、线索二叉树、哈夫曼树、二叉搜索树（排序树）、平衡二叉树、AVL平衡二叉树、红黑树、B树、B+树、堆

1.4 二叉树存储方式

存储的方式有链表和数组两种，用数组存访问速度快，但插入、删除节点操作就比较费时了。实际中更多的是用链来表示二叉树的。

1.4.1 顺序存储结构

二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引。

一棵完全二叉树及其采用顺序存储方式的图示如下：

可以看出，当二叉树为完全二叉树时，结点数刚好填满数组。

当二叉树不为完全二叉树时，采用顺序存储形式的图示如下：

其中，∧表示数组中此位置没有存储结点。此时可以发现，顺序存储结构中已经出现了空间浪费的情况。

1.4.2 链式存储结构

由二叉树定义可知，二叉树的每个结点最多有两个孩子。因此，可以将结点数据结构定义为一个数据和两个指针域。表示方式如图3.11所示：

一棵完全二叉树及其采用链式存储方式的图示如下：

1.5 二叉树遍历方式

二叉树的遍历是指从二叉树的根结点出发，按照某种次序依次访问二叉树中的所有结点，使得每个结点被访问一次，且仅被访问一次。
二叉树的访问次序可以分为四种：

前序遍历、中序遍历、后序遍历、层序遍历。

其实是什么排序，直接看根节点在排序中的位置就行了。比如前序遍历，根节点就在第一个；中序遍历，根节点就在左右子树之间；后序遍历，根节点在最后。

1.5.1 前序遍历

前序遍历通俗的说就是从二叉树的根结点出发，当第一次到达结点时就输出结点数据，按照先向左在向右的方向访问。

该二叉树的前序遍历输出为：
ABDHIEJCFG

1.5.2 中序遍历

中序遍历就是从二叉树的根结点出发，当第二次到达结点时就输出结点数据，按照先向左在向右的方向访问。

该二叉树的中序遍历输出为：
HDIBJEAFCG

1.5.3 后序遍历

后序遍历就是从二叉树的根结点出发，当第三次到达结点时就输出结点数据，按照先向左在向右的方向访问。

该二叉树的后序遍历输出为：
HIDJEBFGCA

1.5.4 层次遍历

层次遍历就是按照树的层次自上而下的遍历二叉树。下图二叉树的层次遍历结果为：

ABCDEFGHIJ

1.5.5 对于二叉树的遍历的典型题型

1）已知前序遍历序列和中序遍历序列，确定一棵二叉树。
例题：若一棵二叉树的前序遍历为ABCDEF，中序遍历为CBAEDF，请画出这棵二叉树。
分析：前序遍历第一个输出结点为根结点，故A为根结点。早中序遍历中根结点处于左右子树结点中间，故结点A的左子树中结点有CB，右子树中结点有EDF。

按照同样的分析方法，对A的左右子树进行划分，最后得出二叉树。

2）已知后序遍历序列和中序遍历序列，确定一棵二叉树。
后序遍历中最后访问的为根结点，因此可以按照上述同样的方法，找到根结点后分成两棵子树，进而继续找到子树的根结点，一步步确定二叉树的形态。
注：已知前序遍历序列和后序遍历序列，不可以唯一确定一棵二叉树。

二、二叉树的遍历实现

2.1 前序遍历

函数的方法：


void PreOrder(Node *root, vector<int> &ans)//形参为结构体类型的指针
{
  if(root==nullptr) return;//递归调用的结束条件
    ans.push_back(root->val);//访问根结点的val值,其实这里就是对该节点的值进行操作，具体怎样操作可以在PreOrder里进行传参实现
    PreOrder(root->left);//前序递归遍历root左子树
    PreOrder(root->right);//前序递归遍历root右子树
}

类的方法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    void Traverse(TreeNode* root, vector<int> &ans){
        if(root == nullptr) return;

        ans.push_back(root->val);   //此时对该节点进行处理(这里是记录它)
        Traverse(root->left, ans);  //一直遍历左子树，直到遍历到最后一个左子树为空的左节点，然后回退一步的root就是最后一个左节点
        Traverse(root->right, ans);      //如果这个节点有右节点，把该右节点当做根节点遍历右子树，注意这里最后退出的其实是更上一个左节点的遍历过程
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        Traverse(root,ans);
        return ans;
    }
};

2.2 中序遍历

函数的方法：

void InOrder(Node *root,vector<int> &ans)//形参为结构体类型的指针
{
  if(root==nullptr) return;//递归调用的结束条件
    InOrder(root->left);//前序递归遍历root左子树
    ans.push_back(root->val);//访问根结点的val值,其实这里就是对该节点的值进行操作，具体怎样操作可以在InOrder里进行传参实现
    InOrder(root->right);//前序递归遍历root右子树
}

类的方法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    void Traverse(TreeNode* root, vector<int> &ans){
        if(root == nullptr) return;

        Traverse(root->left, ans);  //一直遍历左子树，直到遍历到最后一个左子树为空的左节点，然后回退一步的root就是最后一个左节点
        ans.push_back(root->val);   //此时对该节点进行处理(这里是记录它)
        Traverse(root->right, ans);      //如果这个节点有右节点，把该右节点当做根节点遍历右子树，注意这里最后退出的其实是更上一个左节点的遍历过程
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        Traverse(root,ans);
        return ans;
    }
};

2.3 后序遍历

函数的方法：

void PostOrder(Node *root,vector<int> &ans)//形参为结构体类型的指针
{
  if(root==nullptr) return;//递归调用的结束条件
    PostOrder(root->left);//前序递归遍历root左子树
    PostOrder(root->right);//前序递归遍历root右子树
    ans.push_back(root->val);//访问根结点的val值,其实这里就是对该节点的值进行操作，具体怎样操作可以在PostOrder里进行传参实现
}

类的方法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    void Traverse(TreeNode* root, vector<int> &ans){
        if(root == nullptr) return;

        Traverse(root->left, ans);  //一直遍历左子树，直到遍历到最后一个左子树为空的左节点，然后回退一步的root就是最后一个左节点
        Traverse(root->right, ans);      //如果这个节点有右节点，把该右节点当做根节点遍历右子树，注意这里最后退出的其实是更上一个左节点的遍历过程
        ans.push_back(root->val);   //此时对该节点进行处理(这里是记录它)
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        Traverse(root,ans);
        return ans;
    }
};

2.4 层序遍历

以力扣上的一道题为例：

有两种方法：

第一种：直接使用前序遍历，只不过每次记录一下元素应该存在那一个数组，具体看代码

//因为是每一层存一个数组，且从上到下，于是可以使用前序遍历来完成，只不过将每次存的数用一个记录了深度的外层vector来存储
//利用depth变量记录当前在第几层（从0开始），进入下层时depth + 1；
//如果depth >= vector.size()说明这一层还没来过，这是第一次来，所以得扩容咯；
//因为是前序遍历，中-左-右，对于每一层来说，左边的肯定比右边先被遍历到，实际上后序中序都是一样的。。。
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        pre(root, 0, ans);
        return ans;
    }
    
    void pre(TreeNode *root, int depth, vector<vector<int>> &ans) {
        if (!root) return ;
        if (depth >= ans.size())
            ans.push_back(vector<int> {});
        ans[depth].push_back(root->val);
        pre(root->left, depth + 1, ans);
        pre(root->right, depth + 1, ans);
    }
};

第二种：广度优先搜索，使用队列来完成。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;
        if (!root) {
            return ret;
        }
        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int currentLevelSize = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= currentLevelSize; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        
        return ret;
    }
};

三、拓展

关于遍历还有很多种形式，包括结合了某特定的一类二叉树，要结合其性质来进行解答。也有一些是改变了遍历方式，比如：

103. 二叉树的锯齿形层序遍历

子木呀

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
二叉树的相关性质及其前中后层序遍历实现

写在前面：本文前面部分介绍相关概念，后面部分是程序。点击下面链接查看更多！点击此处发现更多一、二叉树的概念1.1 相关术语①结点：包含一个数据元素及若干指向子树分支的信息。②结点的度：一个结点拥有子树的数目称为结点的度。③叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。④分支结点：也称为非终端结点，度不为零的结点称为非终端结点。⑤树的度：树中所有结点的度的最大值。⑥结点的层次：从根结点开始，假设根结点为第1层，根结点的子节点为第2层，依此类推，如果某一.
复制链接

扫一扫