day 7 二叉树H`1

最新推荐文章于 2024-10-16 07:16:00 发布
最新推荐文章于 2024-10-16 07:16:00 发布
阅读量196 收藏 1
点赞数 10
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73924943/article/details/140686031
版权

前序遍历求树的深度，后序遍历求树的高度。深度是从根节点出发计算，高度是从叶子结点出发开始计算。

110. 平衡二叉树

后序：

/**
 * 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 {
public:
    //求高度，后序
    int getHeight(TreeNode* cur){//确定递归函数的参数和返回值
        //确定终止条件
        if(cur==nullptr) return 0;

        //确定单层递归逻辑
        int leftNum=getHeight(cur->left);
        int rightNum=getHeight(cur->right);
        if(leftNum==-1) return -1;
        if(rightNum==-1) return -1;
        if(abs(leftNum-rightNum)>1) return -1;
        else return max(leftNum,rightNum)+1;
    }
    bool isBalanced(TreeNode* root) {
        int res=getHeight(root);
        if(res==-1) return false;
        else return true;
    }
};

257. 二叉树的所有路径

与求深度相似，用前序

/**
 * 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 {
public:
     //确定递归函数参数和返回值
    void travel(TreeNode* cur,vector<int>& path,vector<string>&res){
        path.push_back(cur->val);//应该在递归结束前把叶子结点也加入path
       //确定终止条件
       if(cur->left==nullptr&&cur->right==nullptr){
        string spath="";
        for(int i=0;i<path.size()-1;i++){
            spath+=to_string(path[i]);
            spath+="->";
        }
        spath+=to_string(path[path.size()-1]);
        res.push_back(spath);
       }

       //确定单层递归逻辑
       
       if(cur->left){
        travel(cur->left,path,res);
        path.pop_back();//pop的是cur->left->val
       }
       if(cur->right){
        travel(cur->right,path,res);
        path.pop_back();
       }
        return;

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int>path;
        vector<string>res;
        travel(root,path,res);
        return res;
    }
};

404. 左叶子之和

自己写的：（其实暗含的有终止条件,因为我都加了if条件判断了，只要不满足就不会执行if后的语句，而且主要函数是void类型，走到函数整体结尾就结束了。）

/**
 * 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 {
public:
    int res;
    void traversal(TreeNode* cur){//确定递归函数参数和返回值
        //确定终止条件
       

        //确定单层递归逻辑
        if(cur->left!=nullptr&&cur->left->left==nullptr&&cur->left->right==nullptr){
            res+=cur->left->val;
        }
        if(cur->left){
            traversal(cur->left);
        }
        if(cur->right){
            traversal(cur->right);
        }
    }
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==nullptr) return 0;
        res=0;
        traversal(root);
        return res;
    }
};

后序遍历： 

/**
 * 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 {
public:
    int sumOfLeftLeaves(TreeNode* root) {//确定递归函数参数和返回值
    //确定终止条件
    if(root==nullptr) return 0;//节点为空 -1层
    if(root->left==nullptr&&root->right==nullptr) return 0;
    //节点的左右孩子为空 最后一层，叶子节点

    //确定单层递归逻辑
    int leftNum=sumOfLeftLeaves(root->left);
    if(root->left&&!root->left->left&&!root->left->right){
        leftNum=root->left->val;
    }
    int rightNum=sumOfLeftLeaves(root->right);
    int sum=leftNum+rightNum;
    return sum;
    }
};

513. 找树左下角的值

层序遍历：

/**
 * 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 {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        int res=0;
        if(root==nullptr) return 0;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* cur=que.front();
                que.pop();
                if(i==0) res=cur->val;
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
        }
        return res;
    }
};

递归法：

/**
 * 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 {
public:
    int res;
    int maxDepth=INT_MIN;
    void traversal(TreeNode* cur,int depth){//确定递归函数参数和返回值
        //确定终止条件
        if(cur->left==nullptr&&cur->right==nullptr){
            if(depth>maxDepth){
                res=cur->val;
                maxDepth=depth;
            } 
            return;
        }
        
        //确定单层递归逻辑
        if(cur->left){
            traversal(cur->left,depth+1);
        }
        if(cur->right){
            traversal(cur->right,depth+1);
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root,0);
        return res;
    }
};

112. 路径总和

递归法：

/**
 * 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 {
public:
    bool traversal(TreeNode* root,int sum){//确定递归函数参数和返回值
         //确定终止条件
        if(!root->left&&!root->right&&sum==0) return true;
        if(!root->left&&!root->right&&sum!=0) return false;

        //确定单层递归逻辑
        if(root->left){
            if(traversal(root->left,sum-root->left->val)) return true;
        }
        if(root->right){
            if(traversal(root->right,sum-root->right->val)) return true;
        }
        return false;
    }
    
    bool hasPathSum(TreeNode* root, int targetSum) {
       if(root==nullptr) return false;
       return traversal(root,targetSum-root->val);
    }
};

迭代法：

/**
 * 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 {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) return false;
        stack<pair<TreeNode*,int>> st;
        st.push(pair<TreeNode*,int>(root,root->val));
        while(!st.empty()){
            pair<TreeNode*,int> cur=st.top();
            st.pop();
            if(!cur.first->left&&!cur.first->right&&cur.second==targetSum) return true;
            if(cur.first->left){
                st.push(pair<TreeNode*,int>(cur.first->left,cur.second+cur.first->left->val));
            }
             if(cur.first->right){
                st.push(pair<TreeNode*,int>(cur.first->right,cur.second+cur.first->right->val));
            }
        }
        return false;
    }
};

106. 从中序与后序遍历序列构造二叉树

/**
 * 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 {
public:
    //确定递归函数参数和返回值
    TreeNode* traversal(vector<int>& inorder,vector<int>& postorder){
        //确定终止条件
        if(postorder.size()==0) return nullptr;

        //单层递归逻辑
        //后序数组的最后一个值为中间值
        int rootvalue=postorder[postorder.size()-1];
        TreeNode* root=new TreeNode(rootvalue);

        //叶子结点
        if(postorder.size()==1) return root;

        //第三步：找切割点
        int divideIndex;
        for(int i=0;i<inorder.size();i++){
            if(inorder[i]==rootvalue) divideIndex=i;
        }

        //第四步：切割中序数组  左闭右开
        vector<int> leftInorder(inorder.begin(),inorder.begin()+divideIndex);
        vector<int> rightInorder(inorder.begin()+divideIndex+1,inorder.end());

        //第五步： 切割后序数组
        postorder.resize(postorder.size()-1);
        vector<int> leftPostoder(postorder.begin(),postorder.begin()+leftInorder.size());
        vector<int> rightPostorder(postorder.begin()+leftInorder.size(),postorder.end());
        //第六步： 递归
        root->left=traversal(leftInorder,leftPostoder);
        root->right=traversal(rightInorder,rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder,postorder);
    }
};

654. 最大二叉树

/**
 * 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 {
public:
    //确定递归参数和返回值
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        //确定终止条件
        TreeNode* node=new TreeNode(0);
        if(nums.size()==1){
            node->val=nums[0];
            return node;
        }

        //确定单层递归逻辑
        int maxValue=0;
        int maxIndex;
        for(int i=0;i<nums.size();i++){
            if(nums[i]>maxValue) {
                maxValue=nums[i];
                maxIndex=i;
            }
        }
        node->val=maxValue;
        //构造左子树
        if(maxIndex>0){
            vector<int> leftNums(nums.begin(),nums.begin()+maxIndex);
            node->left=constructMaximumBinaryTree(leftNums);
        }
        //构造右子树
        if(maxIndex<nums.size()-1){
            vector<int> rightNums(nums.begin()+maxIndex+1,nums.end());
            node->right=constructMaximumBinaryTree(rightNums);
        }
        return node;

    }
};

改进：

/**
 * 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 {
public:
    //改进：切割时不构造新数组
    //确定递归函数和参数值
    TreeNode* traversal(vector<int>& nums,int left,int right){
        //确定终止条件
        if(left==right) return nullptr;
        //确定单层递归逻辑
        int maxIndex=left;
        for(int i=left+1;i<right;i++){
            if(nums[i]>nums[maxIndex]) maxIndex=i;
        }
        TreeNode* node=new TreeNode(nums[maxIndex]);

        node->left=traversal(nums,left,maxIndex);
        node->right=traversal(nums,maxIndex+1,right);
        return node;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums,0,nums.size());
        
    }
};

 

lululiangi
关注
DAY17：二叉树（六）完全二叉树的节点个数，注意深度初值和时间复杂度优化
CFY1226的博客
06-07 1818
因此，我们可以先往左递归，计算左侧深度，再一直往右递归，计算右侧深度，如果两侧深度相同，说明子树是满二叉树，直接通过。
day1: 二叉树
哈哈哈的博客
09-05 289
1.二叉树的层序遍历 给你一个二叉树，请你返回其按层序遍历得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 方法1: # Definition for a binary tree node. class TreeNode: def __init_...
Day 6 二叉树
你们的伟仔的博客
12-17 256
二叉树的(层序)遍历相当于广度优先遍历，(前序)遍历相当于深度优先遍历。
代码随想录1刷--day6 二叉树
weixin_42903300的博客
01-23 1023
如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。：是一个有序树，若左子树并不为空，则左子树上所有结点的值均小于它的根结点的值。若右子子树不为空，则右子树上所有结点的值均大于它的根结点的值；
数据结构day7（二叉树）
Hellomino_的博客
04-24 83
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树
国庆day3 二叉树
julie_2000的博客
10-07 154
【代码】国庆day3 二叉树。
DAY15 二叉树part03
weixin_44959140的博客
10-06 705
平衡二叉树、所有路径、左叶子之和、完全二叉树的节点个数
Day11 二叉树 算法
m0_65362103的博客
07-24 172
【代码】Day11 二叉树 算法。
二叉树day1
Kaka_chake的博客
08-07 257
二叉树day1 代码： 二叉树的创建 二叉树的前序遍历 中序遍历 后序遍历 层序遍历 二叉树叶子结点和深度的计算 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; char s[55]; int i, len, num, sum; struct tree { char data; struct tree *Lchild;...
Day 14 二叉树
Max0827的博客
11-29 289
算法学习
数据结构与算法_day5_二叉树
ws297933371的博客
04-24 316
文章目录二叉树的基本概念二叉树的性质二叉树的类型二叉树的节点表示以及树的创建二叉树的遍历深度优先遍历先序遍历中序遍历后序遍历课堂练习广度优先遍历(层次遍历) 二叉树的基本概念 二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree） 二叉树的性质 性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 性...
算法60天-Day16：统计二叉树的深度和结点个数
qq_41387508的博客
10-06 638
代码随想录（截图自参考【1】） 本系列是代码随想录算法训练营的学习笔记之day16，主要记录一下刷题的过程，以及核心知识点和一些值的记录的问题。 代码随想录的资源可以看参考链接【1】。 今日知识点 二叉树基础： 二叉树中的几个关键词：结点、度、叶子结点二叉树的两种主要形式包括满二叉树和完全二叉树 满二叉树（完美二叉树） 满二叉树只有度为0和度为2的结点；在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包
day11-Java（二叉树的存储）
nooooooooooob的博客
03-04 721
文章目录二叉树的存储一、顺序存储结构二、BFS遍历三、代码与数据测试 二叉树的存储 一、顺序存储结构 二叉树的顺序存储是指用一组地址连续的存储单元依次自上而下，自左至右存储完全二叉树上的节点元素，老师的代码中使用的是前面使用过的循环列表对二叉树进行存储。 对于一般的二叉树（如代码中构建的二叉树），为了让数组下标能反映二叉树中结点之间的逻辑关系，只能添加一些并不存在的空节点，让其每个节点与完全二叉树上的结点相对照，再存储到一维数组的对应分量中。昨天的二叉树如下图： 用一个向量来存储： [a, b, c, 0
双亲表示法 如何找到孩子结点_Day57:二叉树的下一个结点
weixin_39610188的博客
11-20 954
剑指Offer_编程题——二叉树的下一个结点题目描述：给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。具体要求:时间限制： C/C++ 1秒，其他语言2秒空间限制： C/C++32M，其他语言64M具体实现：思路一：在做题前，我们应该给大家介绍二叉树的中序遍历的相关知识：在前面的文章里给大家介绍过二叉树的遍历。因...
数据结构与算法：高级数据结构与实际应用
最新发布
weidl001的博客
10-16 1128
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 763
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 619
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——栈
2301_76227083的博客
10-14 724
简单介绍了栈是什么，以及如何用C语言实现一个栈
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1738
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
7-1 完全二叉树的层序遍历
04-22
1. 创建一个空队列，并将根节点入队。 2. 当队列不为空时，执行以下操作： - 弹出队首节点，并访问该节点。 - 如果该节点有左子节点，则将左子节点入队。 - 如果该节点有右子节点，则将右子节点入队。 3. 重复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值