二叉树

最新推荐文章于 2023-10-26 21:35:19 发布
最新推荐文章于 2023-10-26 21:35:19 发布
阅读量378 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/behboyhiex/article/details/82811999
这篇博客详细介绍了二叉树的各种遍历方法，包括前序、中序、后序遍历，并提供了不同的实现策略。同时，还讨论了二叉搜索树的操作，如搜索、修剪、重新排序，以及二叉树的其他操作，如合并、翻转、高度计算、层序遍历等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

二叉树结构 

//Definition for a binary tree node.
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

1、前序 beat 100%

 

144. Binary Tree Preorder Traversal

弹出打印，先压右再压左， 压人顺序：中右左  弹出打印顺序：中左右

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL ) return res;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()){
            root=s.top();
            s.pop();
            res.push_back(root->val);
            if(root->right){
                s.push(root->right);
            }
            if(root->left){
                s.push(root->left);
            }
        }
        return res;
    }
};

2、中序 beat100%

94. Binary Tree Inorder Traversal

判断 不为空 一直压左节点，为空 弹出打印 指向右节点

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root ==NULL) return res;
        stack<TreeNode* > s;
        while(root || !s.empty()){
            if(root){
                s.push(root);
                root=root->left;
            }
            else{
                root=s.top();
                s.pop();
                res.push_back(root->val);
                root=root->right;
            }
        }
        return res;
    }
};

3、后序 beat100%

145. Binary Tree Postorder Traversal

方法一：两个栈  把所有要打印的都push到s2中，统一打印

先序：压栈     ：中右左 打 印：中左右

后序：压栈s1：中左右 压栈s2:中右左 打印：左右中  

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        s1.push(root);
        while(!s1.empty()){
            root=s1.top();
            s1.pop();
            s2.push(root);
            if(root->left){
                s1.push(root->left);
            }
            if(root->right){
                s1.push(root->right);
            }
        }
        while(!s2.empty()){
            root=s2.top();
            s2.pop();
            res.push_back(root->val);
        }
        return res;
    }
};

方法二：判断栈顶c与root关系

1、如果c有左孩子且root不是c的孩子 把c做孩子压栈
2、如果c有右孩子且root不是c的右孩子，把c右孩子压栈
3、其他情况打印c的值，令root=c

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> s1;
        s1.push(root);
        TreeNode * c=NULL;
        while(!s1.empty()){
            c=s1.top();
            if( c->left && root!=c->left && root!=c->right ){
                s1.push(c->left);
            }
            else if(c->right && root !=c->right){
                s1.push(c->right);
            }
            else {
                res.push_back(c->val);
                s1.pop();
                root=c;
            }
        }
        return res;
    }
};

4、层序 100%

 

5、合并两个二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(!t1) return t2;
        if(!t2) return t1;
        TreeNode* node=new TreeNode(t1->val+t2->val);
        node->left=mergeTrees(t1->left,t2->left);
        node->right=mergeTrees(t1->right,t2->right);
        return node;
        
    }
};

6、 二叉搜索树搜索

 

700. Search in a Binary Search Tree

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==NULL || root->val==val) return root;
        return val>root->val?searchBST(root->right,val):searchBST(root->left,val);
    }
};
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        
        if(root==NULL || root->val==val) return root;
        TreeNode* cur = root;
        while(cur->val!=val){
            if(cur->val<val){
                cur=cur->right;
            }
            else 
                cur=cur->left;
            if(cur==NULL ) return NULL;
        }
        return cur;
    }
};

7、N叉树后序遍历

class Solution {
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        if (!root) {
            return res;
        }
        stack<Node*> s1;
        stack<Node*> s2;
        s1.push(root);
        Node* node;
        while (!s1.empty()) {
            node = s1.top();
            s1.pop();
            s2.push(node);
            if (node->children.empty()) {
                continue;
            }
            for (int i = 0; i < node->children.size(); ++i) {
                s1.push(node->children[i]);
            }
        }
        while(!s2.empty()){
            node=s2.top();
            s2.pop();
            res.push_back(node->val);
        }
        return res;
    }
};

8、判断两棵树叶子相同

872. Leaf-Similar Trees

class Solution {
public:
    bool leafSimilar(TreeNode* root1, TreeNode* root2) {
        stack<TreeNode*> s1 , s2;
        s1.push(root1); s2.push(root2);
        while (!s1.empty() && !s2.empty())
            if (dfs(s1) != dfs(s2)) return false;
        return s1.empty() && s2.empty();
    }
    int dfs(stack<TreeNode*>& s) {
        while (true) {
            TreeNode* node = s.top(); s.pop();
            if (node->right) s.push(node->right);
            if (node->left) s.push(node->left);
            if (!node->left && !node->right) return node->val;
        }
    }
};

9、n叉树最大深度

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==NULL) return 0;
        vector<Node* > child;
        if(root){
            child=root->children;
        }
        int maxval=1;
        for(int i=0;i<child.size();i++){
            if(child[i]){
                int depth=1+maxDepth(child[i]);
                maxval=max(maxval,depth);
            }
        }
        return maxval;
    }
};
class Solution {
public:
    int maxDepth(Node* root) {
        int res=0;
        if(root == NULL) return 0；
        dfs(root, 0, res);
        return res + 1;
    }
    
    void dfs(Node* root, int depth, int& res) {     
        res = max(res, depth);    
        if(root == NULL) return ;
        for(int i = 0;i < root->children.size(); i++) {
            dfs(root->children[i], depth + 1, res);
        }
    }
};

10、 n叉树前序

589. N-ary Tree Preorder Traversal

class Solution {
public:
    vector<int> preorder(Node* root) {
        vector<int> res;
        stack<Node*> s;
        s.push(root);
        while(!s.empty()){
            root=s.top();
            s.pop();
            if(root==NULL) continue;
            for(int i=root->children.size()-1;i>=0;i--){
                s.push(root->children[i]);
            }
            res.push_back(root->val);
        }
        return res;
    }
};

11、二叉搜索树修剪 

669. Trim a Binary Search Tree

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        int flag=1;
        TreeNode* res;
        dfs(root,L,R,flag,res);
        return res;
    }
    TreeNode* dfs(TreeNode* root, int L, int R,int flag,TreeNode*& res){
        if(!root) return NULL;
        if(root->val<L){
            return dfs(root->right,L,R,flag,res);
        } 
        else if(root->val>R){
            return dfs(root->left,L,R,flag,res);
        }
        else{
            root->left=dfs(root->left,L,R,2,res);
            root->right=dfs(root->right,L,R,2,res);
            if(flag==1) res=root;
            return root;
        }
        
    }
};

12、 二叉搜索树重新排序

897. Increasing Order Search Tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* increasingBST(TreeNode* root) {
        if(!root) return root;
        stack<TreeNode*> s;
        while(root->left){
            s.push(root);
            root=root->left;
        }
        TreeNode* node =root;
        TreeNode* tail=NULL;
        while(node || !s.empty()){
            if(node){
                s.push(node);
                node=node->left;
            }
            else{
                node=s.top();
                s.pop();
                if(tail){
                    tail->right=node;
                    node->left=NULL;
                }
                tail=node;
                node=node->right;
            }
        }
        return root;
    }
    
};

13、 二叉树高度

104. Maximum Depth of Binary Tree

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root) return 0;
        int l=maxDepth(root->left);
        int r=maxDepth(root->right);
        return max(l,r)+1;
    }
};

14、二叉树每层平均值

637. Average of Levels in Binary Tree

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        if(!root) return res;
        queue<TreeNode*> q;
        q.push(root);
        q.push(NULL);
        double sum=0;
        int cnt=0;
        while(!q.empty()){
           root=q.front();
            q.pop();
            if(!root){
                res.push_back(sum/cnt);
                if(!q.empty()){
                    q.push(NULL);
                }
                sum=0;
                cnt=0;
                continue;
            }
            cnt++;
            sum+=root->val;
            if(root->left){
                q.push(root->left);
            }
            if(root->right){
                q.push(root->right);
            }
        }
        return res;
    }
};

15、二叉树翻转

226. Invert Binary Tree

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root) return root;
        TreeNode* invert=new TreeNode(root->val);
        invert->left=invertTree(root->right);
        invert->right=invertTree(root->left);
        return invert;
    }
};

16、 N叉树层序遍历

429. N-ary Tree Level Order Traversal

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        if(!root) return res;
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int len=q.size();
            vector<int> tmp;
            for (int i = 0; i < len; i++){
                root=q.front();
                q.pop();
                tmp.push_back(root->val);
                vector<Node*> child= root->children;
                for(int i=0;i<child.size();i++){
                    q.push(child[i]);
                }
                
            }
            res.push_back(tmp);
        }
        return res;
    }
};

17、二叉树序列化

class Solution {
public:
    string tree2str(TreeNode* t) {
        string s="";
        if(!t) return s;
        build_string(t,s);
        return s;
    }
    void build_string(TreeNode* t ,string& s){
        if(!t){
            s+="()";
            return;
        }
        if(t){
            s+=to_string(t->val);
        }
        if(t->left){
            s+="(";
            build_string(t->left,s);
            s+=")";
        }
        else if(t->right){
            s+="()";
        }
        if(t->right){
            s+="(";
            build_string(t->right,s);
            s+=")";
        }
        
    }
};

18、二叉搜索树转换

538. Convert BST to Greater Tree

class Solution {
public:
    vector<TreeNode *> num;
    TreeNode* convertBST(TreeNode* root) {
        tree2vec(root);
        if(num.size()<=1) return root;
        for(int i=num.size()-2;i>=0;i--){
            num[i]->val+=num[i+1]->val;
        }
        return root;
    }
private:
    void tree2vec(TreeNode *root) {
        if (!root) return;
        tree2vec(root->left);
        num.push_back(root);
        tree2vec(root->right);
    }
};

1、平衡二叉树 

beat 100% 包含剪枝，底层不平衡，就一路返回，且当左子树高度为-1时，就没必要去求右子树的高度

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        return getdepth(root)!=-1;
    }
private:
    int getdepth(TreeNode* root){
        if(root==NULL) return 0;
        int left=getdepth(root->left);
        if(left==-1) return -1;
        int right=getdepth(root->right);
        if(right==-1) return -1;
        return abs(left-right)>1? -1: max(left,right)+1;
    }
};

2、判断二叉搜索树

方法一：

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return isValidBST(root, NULL, NULL);
    }

    bool isValidBST(TreeNode* root, TreeNode* minNode, TreeNode* maxNode) {
        if(!root) return true;
        if(minNode && root->val <= minNode->val || maxNode && root->val >= maxNode->val)
            return false;
        return isValidBST(root->left, minNode, root) && isValidBST(root->right, root, maxNode);
    }
};

方法二：in-order

class Solution {
public:
    bool flag;
    bool isValidBST(TreeNode* root) {
        flag=true;
        TreeNode* pre=NULL;
        in_order(root,pre);
        return flag;
    }
    void in_order(TreeNode* root,TreeNode*& pre){
        if(root==NULL) return ;
        in_order(root->left,pre);
        if(pre!=NULL&&pre->val>=root->val) flag=false;
        pre=root;
        in_order(root->right,pre);
    }
};

 

二叉树中的结点查找、插入
洋葱汪的博客
05-29 9140
前面实现了通用树结构，介绍了树到二叉树的转换，这节实现二叉树中的结点查找、插入 目录 1、 二叉树的存储结构设计 2、二叉树中的结点查找操作 3、二叉树中的结点插入操作 1、 二叉树的存储结构设计 目标：完成二叉树和二叉树结点的存储结构设计 设计要点 － BTree为二叉树结构，每个结点最多只有两个后继结点 ...
Java“树结构TreeNode”用法详解，二叉树用法实现代码！！！
最新发布
wwwwwmmn的博客
03-10 7014
本篇文章详细整理了TreeNode的用法，二叉树四种遍历的详细实现代码，构造二叉树，查找父节点等……
TreeNode 二叉树算法面试题，源于大厂真题和《剑指offer》，欢迎大家留言补充~~
Java Punk
11-26 778
二叉树（Binary tree）是一种非常重要的数据结构，更是算法题中高频出现的知识点，不管是为了应付工作还是面试，都有必要深度学习一下。
【数据结构与算法】初识二叉树(中)
冲击大厂之路!!!
09-29 1201
二叉树中篇，详解二叉树的三种遍历方式，以及二叉树的模拟实现！
C++ 输入数组利用递归建立二叉树——层序、前序、中序、后序
xuefeng的博客
08-23 4765
C++ 输入数组利用递归建立二叉树——层序、前序、中序、后序 1、输入数组要求 数组是按照层序输入的，当该结点为空时，用‘#’代替空的位置，如下图。（这里直接截取大话数据结构里面的图片） 2、二叉树结构定义 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : v...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
二叉树模拟器.py二叉树模拟器.py
07-24
二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py...
数据结构MOOC|二叉树的表示
笔记本
05-28 662
1.链表表示法struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} };2.数组表示法：将二叉树看作完全二叉树缺点，如果树很稀疏的话，空间浪费比较大。优点，父子结点、兄弟结点之间通过下标...
c++实现二叉排序树的基本操作
weixin_45902800的博客
03-18 1145
二叉树结构体 typedef struct TreeNode { char val; TreeNode* left; TreeNode* right; TreeNode() :val(NULL), left(NULL), right(NULL) {}; TreeNode(char x) :val(x), left(NULL), right(NULL) {}; }*BiTree; 二叉排序树的插入 也可通过插入建立二叉排序树 void insert_Tree(BiTree &T, char
C++结构体定义的同时完成初始化：TreeNode(int x) :val(x), left(NULL), right(NULL) {}；
qq_53234413的博客
10-26 307
笔者c++初学选手，在代码随想录二叉树章节学习二叉树定义的方法时遇到了一种结构体初始化的方法：TreeNode(int x) :val(x), left(NULL), right(NULL) {};这一步完成了结构体的初始化，将int型变量赋值给结构体中的int型变量val，两个TreeNode指针型变量left，right（代表二叉树的左右节点）都赋值为NULL。
编程题分类——树
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
10-23 463
目录前言正文按之字形顺序打印二叉树参考 前言 正文 按之字形顺序打印二叉树 code /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vecto
LeetCode之相同的树（一百）
liuzhen007的专栏
08-07 603
分析：先比较当前节点，值相等再依次比较左子树和右子树，自然而然会想到递归的方法。
二叉树的基本操作
marcushbs的博客
02-12 358
数据结构的一些知识很久没碰了，忘得差不多了都，来回顾总结一下，本篇先写一下二叉树相关的一些操作。 二叉树定义 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的创建 通过输入先序二叉树序列创建二叉树，用'#'字符代表空节点。 //通过先序输入创建二叉树 TreeNode* CreateTreeByIn...
数据结构个人总结系列--二叉树
weixin_68966886的博客
08-26 396
数据结构个人总结二叉树系列
114. 二叉树展开为链表
专心扫地
05-09 234
/** * 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) {} ...
【LeetCode】-- 144. 二叉树的前序遍历
局部变量和全局变量
08-14 761
给你二叉树的根节点root，返回它节点值的前序遍历。
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值