二叉树及其线索化

最新推荐文章于 2023-08-13 09:07:29 发布
最新推荐文章于 2023-08-13 09:07:29 发布
阅读量1.1k 收藏 11
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/104139531
版权

概念

1、结点的度：结点拥有的子树个数
2、树的度：树内各结点度的最大值
3、叶结点(终端结点)：度为0的结点
4、分支结点：度大于0的结点
5、满二叉树：所有的分支结点都存在左右孩子，左右的叶子结点都在同一层的二叉树
6、完全二叉树：对一棵具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点中位置完全相同，那此树就是一棵满二叉树(结点只能从左到右，从上往下生长)
7、平衡二叉树：如果某二叉树中任意结点的左右子树的深度相差不超过1 ，那么它就是一棵平衡二叉树

性质

1、在二叉树的第i层最多有2^(i-1)个结点
2、深度为k的二叉树最多有2^k-1个结点
3、对任何一颗二叉树，若有n0个叶结点，度为2的结点数位n2，则n0 = n2 + 1
(树枝数 = n0 + n1 + n2 -1 = n1 + 2*n2)
4、具有n个结点的完全二叉树的深度为[log2n] + 1(2为底，n的对数)
5、对一棵有n个结点的完全二叉树按层编号(从0开始)：
A.若 i = 0，则结点 i 为二叉树的根；若 i > 0, 则其双亲为[(i-1) / 2]
B.若 2 * i +1 > n，则结点 i 无左孩子，否则其左孩子是结点 2 * i + 1
C.若 2 * i +2 > n，则结点 i 无右孩子，否则其右孩子是结点 2 * i + 2

遍历二叉树

先序遍历：根左右

在这里插入图片描述
先序代码：

void PreOrderTraverse(Node* node){
    if(node == NULL) return ;
    cout<<node->data<<" ";
    PreOrderTraverse(node->lchild);
    PreOrderTraverse(node->rchild);
}
中序遍历：左根右

在这里插入图片描述
中序代码：

void InOrderTraverse(Node* node){
    if(node == NULL) return ;
    InOrderTraverse(node->lchild);
    cout<<node->data;
    InOrderTraverse(node->rchild);
}
后序遍历：左右根

在这里插入图片描述
后序代码：

void PostOrderTraverse(Node* node){
    if(node == NULL) return ;
    PostOrderTraverse(node->lchild);
    PostOrderTraverse(node->rchild);
    cout<<node->data;
}
层次遍历：从上到下，从左到右

在这里插入图片描述

1、把根节点A放入队列，此时队列为：A，队列头指针指向A，也就是队列第一个元素

2、把当前队列头指针所指元素的左右儿子放入队列，即将B C放入队列，此时队列为A B C ，队列头指针向后移一格，此时指向B

3、不断重复2步骤。此时把B的左右儿子取出来放入队尾，队列变为A B C D，
队列头指针后移，指向C。把C的左右儿子取出来放入队尾，队列变为A B C D E F
队列头指针后移，指向D。把D的左右儿子取出来放入队尾，队列变为A B C D E F G H
队列头指针后移，指向E。把E的左右儿子取出来放入队尾，队列变为A B C D E F G H I
4、结束条件，队列头指针和为指针重合时，输出最后一个元素，算法结束！

也就是说，把这个队列从头到尾输出一遍，就是按层遍历，这个队列是动态的，只要有子节点，子节点就会不停的加入队尾，但总有子节点没有的时候，所以，队列尾指针肯定有不再移动的时候，而头指针一直在一步一步向下移，总会有首尾指针重合的时候，即标志着算法结束。

层次遍历代码：

void LevelOrderTraverse(Node* root){
    if(root == NULL) return ;
    queue<Node*> q;
    q.push(root);
    while(!q.empty()){
        cout<<q.front()->data<<" ";
        if(q.front()->lchild != NULL){
            q.push(q.front()->lchild);
        }
        if(q.front()->rchild != NULL){
            q.push(q.front()->rchild);
        }
        q.pop();
    }
    cout<<endl;
}
注:已知中序遍历和先序遍历结果，或已知中序遍历和后序遍历结果可以还原二叉树

二叉树深度

最简单的方式就是使用递归的方式来遍历二叉树，在递归的处理函数中逐渐增加二叉树的深度

int getDeepth(Node* node){
    if(node == NULL) return 0;
    int left = getDeepth(node->lchild);
    int right = getDeepth(node->rchild);
    return left>right ? left+1 : right+1;
}
图解(深度为3)：

在这里插入图片描述

注：‘#’ 表示此结点为空，向调用处返回0，实际的二叉树如下

在这里插入图片描述

判断平衡二叉树

递归地检查二叉树中所有结点的左右子树的深度之差，若都相差不超过1 ，那么它就是一棵平衡二叉树

bool isBalanced(Node* node){
    if(node == NULL) return true;
    int left = getDeepth(node->lchild);
    int right = getDeepth(node->rchild);
    int gap = abs(left - right);
    //对于当前结点而言，左右子树的深度之差大于1，不平衡
    if(gap > 1)
        return false;
    //对于当前结点而言，左右子树的深度只差不大于1，平衡
    //接着检查其左右子树是否平衡
    return isBalanced(node->lchild) && isBalanced(node->rchild);
}
构造二叉搜索树的insert操作
Node* insert(Node* node, int num){
    if(node == nullptr){
        node = new Node(num);//当前结点为空，直接构造结点挂上
    }else if(node->val > num){
        node->left = insert(node->left, num);
    }else if(node->val < num){
        node->right = insert(node->right, num);
    }
    //相等直接返回
    return node;
}
将有序数组转为二叉搜索树
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return getBST(nums, 0, nums.size() - 1);
    }
    TreeNode* getBST(vector<int>& nums, int l, int r){
        if(l > r){
            return nullptr;
        }
        int mid = (l + r) / 2;
        TreeNode* node = new TreeNode(nums[mid]);
        node->left = getBST(nums, l, mid - 1);
        node->right = getBST(nums, mid + 1, r);
        return node;
    }
};
面向过程完整代码：
#include<iostream>
#include<queue>

using namespace std;

struct Node{
    char data;
    Node* lchild;
    Node* rchild;
}Node;

//按先序输入二叉树结点的值
//根据输入序列创建二叉树
//用双指针是为了将根结点传入，执行函数完成后，还能通过此根结点找到树
void CreateTree(Node** node){
    char temp;
    cin>>temp;
    if(temp == '#')
        *node = NULL;
    else{
        *node = (Node*)malloc(sizeof(Node));
        (*node)->data = temp;
        CreateTree(&((*node)->lchild));
        CreateTree(&((*node)->rchild));    
    }
}

//先序遍历
void PreOrderTraverse(Node* node){
    if(node == NULL) return ;
    cout<<node->data<<" ";
    PreOrderTraverse(node->lchild);
    PreOrderTraverse(node->rchild);
}

//中序遍历
void InOrderTraverse(Node* node){
    if(node == NULL) return ;
    InOrderTraverse(node->lchild);
    cout<<node->data;
    InOrderTraverse(node->rchild);
}

//后序遍历
void PostOrderTraverse(Node* node){
    if(node == NULL) return ;
    PostOrderTraverse(node->lchild);
    PostOrderTraverse(node->rchild);
    cout<<node->data;
}

void LevelOrderTraverse(Node* root){
    if(root == NULL) return ;
    queue<Node*> q;
    q.push(root);
    while(!q.empty()){
        cout<<q.front()->data<<" ";
        if(q.front()->lchild != NULL){
            q.push(q.front()->lchild);
        }
        if(q.front()->rchild != NULL){
            q.push(q.front()->rchild);
        }
        q.pop();
    }
    cout<<endl;
}

int getDeepth(Node* node){
    if(node == NULL) return 0;
    int left = getDeepth(node->lchild);
    int right = getDeepth(node->rchild);
    return left>right ? left+1 : right+1;
}

bool isBalanced(Node* node){
    if(node == NULL) return true;
    int left = getDeepth(node->lchild);
    int right = getDeepth(node->rchild);
    int gap = abs(left - right);
    //对于当前结点而言，左右子树的深度之差大于1，不平衡
    if(gap > 1)
        return false;
    //对于当前结点而言，左右子树的深度只差不大于1，平衡
    //接着检查其左右子树是否平衡
    return isBalanced(node->lchild) && isBalanced(node->rchild);
}

int main(){
    Node* root = (Node*)malloc(sizeof(Node));
    //测试数据AB#D##C##
    cout<<"输入数据：";
    CreateTree(&root);
    cout<<"先序遍历结果：";
    PreOrderTraverse(root); 
    cout<<endl;
    cout<<"中序遍历结果：";
    InOrderTraverse(root); 
    cout<<endl;
    cout<<"后序遍历结果：";
    PostOrderTraverse(root); 
    cout<<endl;
    cout<<"层次遍历结果：";
    LevelOrderTraverse(root); 
    cout<<"二叉树的深度：";
    cout<<getDeepth(root)<<endl;
    cout<<"是平衡二叉树吗？"<<isBalanced(root)<<endl;
    return 0;
}

运行结果：
在这里插入图片描述

注：创建结果如上图(二叉树深度部分的图)

面向对象版完整代码

#include<iostream>
#include<queue>

using namespace std;

typedef struct Node{
    char data;
    struct Node* lchild;
    struct Node* rchild;
}Node;

class Tree{
    private:
        Node* root;
        int tree_deepth;
        //先序
        void Pre(Node* node){
            if(node == NULL) return ;
            cout<<node->data<<" ";
            Pre(node->lchild);
            Pre(node->rchild);
        }  
        //中序       
        void In(Node* node){
            if(node == NULL) return ;
            In(node->lchild);
            cout<<node->data;
            In(node->rchild);
        }
        //后序
        void Post(Node* node){
            if(node == NULL) return ;
            In(node->lchild);
            In(node->rchild);
            cout<<node->data;
        }  
        //层次
        void Level(Node* node){
            if(root == NULL) return ;
            queue<Node*> q;
            q.push(root);
            while(!q.empty()){
                cout<<q.front()->data<<" ";
                if(q.front()->lchild != NULL){
                    q.push(q.front()->lchild);
                }
                if(q.front()->rchild != NULL){
                    q.push(q.front()->rchild);
                }
                q.pop();
            }
            cout<<endl;

        }

        void CreateTree(Node** node){
            char temp;
            cin>>temp;
            if(temp == '#')
                *node = NULL;
            else{
                *node = (Node*)malloc(sizeof(Node));
                (*node)->data = temp;
                CreateTree(&((*node)->lchild));
                CreateTree(&((*node)->rchild));    
            }
        }

        int Deepth(Node* node){
            if(node == NULL) return 0;
            int left = Deepth(node->lchild);
            int right = Deepth(node->rchild);
            return left>right ? left+1 : right+1;
        }

        bool Balanced(Node* node){
            if(node == NULL) return true;
            int left = Deepth(node->lchild);
            int right = Deepth(node->rchild);
            int gap = abs(left - right);
            //对于当前结点而言，左右子树的深度之差大于1，不平衡
            if(gap > 1)
                return false;
            //对于当前结点而言，左右子树的深度只差不大于1，平衡
            //接着检查其左右子树是否平衡
            return Balanced(node->lchild) && Balanced(node->rchild);
        }
    public:
        Tree(){
            root = (Node*)malloc(sizeof(Node*));
            cout<<"输入数据：";
            CreateTree(&root);
        }
        void PreOrderTraverse(){
            Pre(root);
        }

        void InOrderTraverse(){
            In(root);
        }

        void PostOrderTraverse(){
            Post(root);
        }

        void LevelOrderTraverse(){
            Level(root);
        }

        void CountDeepth(){
            tree_deepth = Deepth(root);
        }

        int getDeepth(){
            CountDeepth();
            return tree_deepth;
        }

        bool isBalanced(){
            return Balanced(root);
        }
};

int main(){
    //AB#D##C##
    Tree tree;
    cout<<"先序遍历结果：";
    tree.PreOrderTraverse(); 
    cout<<"中序遍历结果：";
    tree.InOrderTraverse(); 
    cout<<"后序遍历结果：";
    tree.PostOrderTraverse(); 
    cout<<endl;
    cout<<"层次遍历结果：";
    tree.LevelOrderTraverse(); 
    cout<<"树的深度为："<<tree.getDeepth()<<endl;
    cout<<"是平衡二叉树吗？"<<tree.isBalanced()<<endl;
    return 0;
}
线索二叉树

将普通二叉树线索化成中序线索二叉树：
在这里插入图片描述
线索二叉树的数据结构：
在这里插入图片描述
中序线索二叉树的存储结构：
在这里插图片描述

将普通二叉树线索化成先序线索二叉树：
在这里插入图片描述
先序线索二叉树的存储结构：
在这里插入图片描述
将普通二叉树线索化成后序线索二叉树：
在这里插入图片描述
后序线索二叉树的存储结构：
在这里插入图片描述

用两个指针，在中序遍历的同时，将二叉树中序线索化：
在这里插入图片描述
中序线索化实现代码：
在这里插入图片描述

在这里插入图片描述
先序线索化实现代码：

在这里插入图片描述

后序线索化实现代码：

在这里插入图片描述
注： 只有构造先序线索二叉树时，才需要判断左指针是否是真实的结点。因为先序遍历的顺序是【根，左，右】，访问根结点后可能会线索化左指针。改变左指针后，马上再接着访问当前根结点的左孩子，就会访问到当前根结点的父结点，然后又访问回来…，这样死循环下去。

别的顺序线索化二叉树，不需要判断左指针是否是真实的结点。中序线索化时，先访问左孩子，由于左孩子线索化后，会接着访问根结点，不会再往下层访问，所以线索化对中序遍历没有影响。后序线索化同样的分析。

中序线索化二叉树完整代码：

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>

using namespace std;

struct TreeNode {
    char val;
    TreeNode *left;
    TreeNode *right;
    int ltag;
    int rtag;
    TreeNode(char x) : val(x), left(nullptr), right(nullptr), ltag(0), rtag(0) {

    }
};

TreeNode* buildTree(vector<char>& preorder, vector<char>& inorder) {
    if(preorder.size() == 0){
        return nullptr;
    }
    TreeNode* root = new TreeNode(preorder[0]);
    auto mid = find(inorder.begin(), inorder.end(), preorder[0]); //指向根结点值的迭代器
    char left_nodes = mid - inorder.begin(); //左子树结点数目
    vector<char> left_preorder(preorder.begin()+1, preorder.begin()+1+left_nodes);
    vector<char> right_preorder(preorder.begin()+1+left_nodes, preorder.end());
    vector<char> left_inorder(inorder.begin(), mid);
    vector<char> right_inorder(mid+1, inorder.end());
    root->left  = buildTree(left_preorder, left_inorder);
    root->right = buildTree(right_preorder, right_inorder);
    return root;
}

void inVisit(TreeNode* cur, TreeNode* &pre){
    if(cur->left == nullptr){
        cur->left = pre;
        cur->ltag = 1;
    }
    if(pre != nullptr && pre->right == nullptr){
        pre->right = cur;
        pre->rtag = 1;
    }
    pre = cur;
}

void inThread(TreeNode* root, TreeNode* &pre){
    if(root != nullptr){
        inThread(root->left, pre);
        inVisit(root, pre);
        inThread(root->right, pre);
    }
}

TreeNode* getInThreadTree(TreeNode* root){
    TreeNode* pre = nullptr;
    if(root != nullptr){
        inThread(root, pre);
        if(pre->right == nullptr){
            pre->rtag = 1;                //处理遍历的最后一个结点
        }
    }
    return root;
}

int main(){
    vector<char> preorder = {'A', 'B', 'D', 'G', 'E', 'C', 'F'};
    vector<char> inorder = {'D', 'G', 'B', 'E', 'A', 'F', 'C'};
    TreeNode* root = buildTree(preorder, inorder);  //构造上图的二叉树
    TreeNode* inThreadTree = getInThreadTree(root);
    cout<<inThreadTree->right->left->right->val<<endl;  //验证线索化是否正确
    return 0;
}
树的孩子兄弟表示法：

在这里插入图片描述
在这里插入图片描述

森林与二叉树相互转换：

在这里插入图片描述
先将每棵树按照孩子兄弟表示法转换为二叉树，然后把C、D当作B的兄弟结点，挂到B的后子树上，就像这样：
在这里插入图片描述

将二叉树按照孩子兄弟表示法还原为森林：

在这里插入图片描述

树的先根遍历

先访问根，在从左往后访问子树
在这里插入图片描述

树的后根遍历

先从左往后访问子树，最后访问根
在这里插入图片描述
因为树中，不管是左孩子还是右孩子对应到孩子兄弟表示法的二叉树中，都是左孩子。所以树中的【左、右、根】对应成了二叉树中的【左、根】，换到下一颗树遍历时，二叉树就变成了右孩子，故 树的后序遍历 = 对应二叉树的中序遍历

树的层次遍历

在这里插入图片描述

森林的遍历
  1. 森林的先序遍历 = 从左到右对每棵树先序遍历 = 对应二叉树的先序遍历
  2. 森林的中序遍历 = 从左到右对每棵树后序遍历 = 对应二叉树的中序遍历
bugcoder-9905
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的线索化 C++代码
04-23
### 二叉树的线索化及其C++实现 #### 一、什么是二叉树的线索化？ 二叉树的线索化是一种对二叉树进行特殊处理的方法，它通过对二叉树节点指针域的改造来使得能够高效地进行中序遍历等操作。在未经过线索化的二叉树...
【线索二叉树】C++代码及线索化过程详解
z135733的博客
05-23 1305
不含头结点的线索二叉树详解~快来看看吧！
【数据结构】线索二叉树（适用场景+图文推导过程+C语言代码实现）
crr411422的博客
03-31 4995
在实际问题中，如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。我们对二叉树以某种次序遍历使其变为线索二叉树的过程称做是线索化。
二叉树
qq_37254296的博客
09-04 539
一、定义 二叉树是 n 个节点的有限集合，该集合或者为空集（空二叉树），或者由一个根节点和两棵互不相交的、分被称为根节点的左子树和右子树组成。下图为一棵普通的二叉树： 二、二叉树的特点 由二叉树定义以及图示分析得出二叉树有以下特点： 每个节点最多有两棵子树，所以二叉树中不存在度大于2的节点。 左子树和右子树是有顺序的，次序不能任意颠倒。 即使树中某节点只有一棵树，也要区分它是左子树...
数据结构 | 线索化二叉树
qq_42190335的博客
08-13 1028
线索化二叉树的由来 在二叉树中，我们经常发现，有许多的叶子结点的左右指针没有完全利用上，于是我们希望能将这些指针充分的利用，所以就出现了线索化二叉树 线索化二叉树的基本介绍 1、n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为线索）； 2、这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树。根据线索性质的不同，线索二叉树可分为前序线索二叉树，中序以及后序三种； 3、每一个结点的前一个结点称之为前驱结点
【二叉树：3】线索二叉树
NorthSmile的博客
09-24 847
线索二叉树：对节点加上线索线索后的二叉树称为线索二叉树；建立线索二叉树：通过某种遍历方式对二叉树进行遍历，并在遍历过程中对其节点添加线索，使其变为线索二叉树；
二叉树先中后序线索化及其遍历
05-02
线索化是将二叉树的非空链域转换为线索，以便在不使用栈或递归的情况下进行二叉树的遍历，这对于空间优化和某些特定场景下的高效访问非常重要。 1. 先序遍历：在二叉树的先序遍历中，访问顺序为根节点 -> 左子树 ->...
线索二叉树的实现.doc
最新发布
04-29
- **逻辑设计**：首先要明确抽象数据类型（ADT）的定义，确定二叉树节点的数据结构以及线索化的逻辑结构。此外，还需要设计出各主要模块的算法，并绘制出模块之间的调用关系图，以便于理解各个部分如何协作完成任务...
C语言数据结构之线索二叉树及其遍历
08-29
`InOrderThread`函数展示了如何在中序遍历过程中线索化二叉树，但这里只给出了部分代码，未完整展示如何处理前驱节点`Pre`的初始值。通常，中序遍历时，当遍历到一个空的左子节点时，可以将当前节点设为前驱节点的...
【二叉树】OJ-顺序建立完全二叉树 ❀ 努力更新DAY1
weixin_43590513的博客
12-22 625
假设用顺序表来表示一棵完全二叉树。从根到叶结点按层次从 开始编号，同一层次从左到右编号，数据存储在对应的数组元素中。试编写算法由此顺序存储结构建立该二叉树的二叉链表。
数据结构-线索化二叉树
yao_wen_yu的博客
10-26 5204
文章目录1、什么是线索二叉树2、中序线索化二叉树2.1 中序线索化二叉树实现2.2 中序线索化二叉树遍历实现3、先序线索化二叉树3.1 先序线索化二叉树实现3.2 先序线索化二叉树遍历实现4、后序线索化二叉树4.1 后序线索化二叉树实现4.2 后序线索化二叉树遍历实现 1、什么是线索二叉树 线索二叉树是二叉树的一种，我们先看一个二叉树存储例子。 上图中的 # 是空的，会浪费一部分空间，如果我们希望将这些空的指针充分利用，让各个节点都可以指向自己的前驱结点和后继节点，那就需要使用到线索二叉树。 现有一颗节
数据结构——二叉树线索化
m0_74222411的博客
08-13 2184
根据某种遍历序列（前、中后序遍历），先确定下来每个节点的前驱和后继。对于每个节点来说，他的左右指针可能没有指向节点（值为NULL），这时候我们可以运用这些“空闲”的指针。比如：左指针如果有空闲，就用这个指针指向这个节点对应遍历序列的前驱，右指针如果有空闲，就用这个指针指向这个节点对应遍历序列的后继。（注意：遍历序列中一头一尾是没有前驱或者后继的，所以如果指针有空闲，我们还是当它指向的是孩子，而不是前驱或者后继）对于每个节点都实现了步骤2后，线索化完成。
20. 线索化二叉树及其代码实现
乖乖虎学java
03-10 572
20
线索化二叉树代码实现（细！！）
qq_58424960的博客
02-20 304
线索化二叉树代码实现
线索二叉树（图解+完整代码）
weixin_54186646的博客
04-26 2万+
线索化二叉树的图解与完整C语言代码
二叉树的线索化
热门推荐
编程小霸王的Blog
12-05 2万+
线索二叉树(Threaded BinaryTree) 1.线索二叉树的基本概念       遍历二叉树是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。 这实质上是对一个非线性结构进行线性化操作。使每个结点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。      例如二叉树结点的中序序列a+b*c-d-e/f中，“c”
数据结构7--树1
温故知新
08-07 860
数据结构--树树的逻辑结构树的存储结构 笔记来源： 懒猫老师. 树的逻辑结构 树的定义： n (n≥0) 个结点的有限集合。当n=0时，称为空树，任意一棵非空树满足以下条件： 有且仅有一个特定的称为根的结点; 当 n > 1 时，除根结点之外的其余结点被分成 m （m>0）个互不相交的有限集合 T1, T2，…Tm，其中，每个集合又是一棵树，并称为这个根结点的子树。 树的定义采用递归方法 树的基本术语： 结点的度：结点所拥有的子树的个数。 树的度：树中各结点度的最大值。 叶子
线索二叉树详解及代码实现
学习永无止境
05-14 719
在二叉树的结点上加上线索的二叉树称为线索二叉树(Threaded BinaryTree)，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化，从而使得每个结点（除了第一个和最后一个结点以外）都有一个直接前驱和直接后继。 原理 ni表示度数为i的结点个数，很明显，i=0,1,2 首先对于一个含有n个结点的二叉树，空指针的总数为2n0+n1， 又因为n=n0+n1+n2=n1+2n2+1，从而得到n0=n2+1， 因此空指针的总数为2n0+n1=n0+n
线索化二叉树-（c实现，代码已测试），严蔚敏版数据结构
qq_57525683的博客
10-26 565
线索化二叉树、数据结构、考研
C语言实现的线索化二叉树及其遍历
本篇文章详细介绍了如何在C语言环境下实现线索化二叉树的数据结构和算法。线索化二叉树是一种特殊的二叉树存储...通过阅读本文，读者不仅能掌握线索化二叉树的实现，还能理解不同遍历方式及其在线索化过程中的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bugcoder-9905

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值