二叉树和递归-刷题笔记

最新推荐文章于 2022-03-24 20:46:18 发布
最新推荐文章于 2022-03-24 20:46:18 发布
阅读量189 收藏 1
点赞数
分类专栏： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36585574/article/details/106317088
版权

在这里插入图片描述

文章目录

1、二叉树最小深度

Leetcode 111
【题目】
给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回它的最小深度 2.

最小深度条件判断的和最大深度不一样，这个要注意

/**
 * 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:
    int minDepth(TreeNode* root) {
        if(root==NULL)
            return 0;
        else if(root->left!=NULL&&root->right!=NULL)
        {
            return min(minDepth(root->left),minDepth(root->right))+1;
        }
        else if(root->left==NULL)
        {
            return minDepth(root->right)+1;
        }
        else
        {
            return minDepth(root->left)+1;
        }
        
    }
};

2、翻转二叉树

Leetcode 226
【题目】
翻转一棵二叉树。

示例：

输入：
4
/
2 7
/ \ /
1 3 6 9
输出：
4
/
7 2
/ \ /
9 6 3 1

用递归的方法思考

/**
 * 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* invertTree(TreeNode* root) {
        if(root==NULL)
            return NULL;
        TreeNode* L= invertTree(root->left);
        TreeNode* R = invertTree(root->right);
        root->left=R;
        root->right=L;
        return root;

    }
};

3、相同的树

Leetcode 100
【题目】
给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:
1 1
/ \ /
2 3 2 3
[1,2,3], [1,2,3]
输出: true

示例 2:

输入:
1 1
/
2 2
[1,2], [1,null,2]
输出: false

示例 3:

输入:
1 1
/ \ /
2 1 1 2
[1,2,1], [1,1,2]
输出: false

用递归的方法，递归的关键就是终止条件和递归过程

上代码

/**
 * 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:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==NULL&&q==NULL)
        return true;
        else if(p==NULL||q==NULL)
        return false;
        if(p->val!=q->val)
        {
            return false;
        }
        else
        {
            return (isSameTree(p->left,q->left)&&isSameTree(p->right,q->right));            
        }
        
    }
};

4、对称二叉树

Leetcode 101
【题目】
给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

1
/
2 2
/ \ /
3 4 4 3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

1
/
2 2
\
3 3

我是把之前的总结了一下，先镜像，之后再比较左右是否相等。

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
        return true;
        TreeNode* t = reverse(root->right);
        return same(root->left,t);
        
    }
    TreeNode* reverse(TreeNode* root)
    {
        if(root==NULL)
        {
            return NULL;
        }
        TreeNode* L = reverse(root->left);
        TreeNode* R = reverse(root->right);
        root->left=R;
        root->right=L;
        return root;
    }
    bool same(TreeNode*p, TreeNode*q)
    {
        if(p==NULL&&q==NULL)
        return true;
        else if (p==NULL||q==NULL)
        return false;
        if(p->val!=q->val)
            return false;
        else
            return same(p->left,q->left)&&same(p->right,q->right);

    }
};

还有就是在原地用迭代的方式，最主要的是要看可以迭代的部分，这里需要的注意就要比较到第二层的结点之间。呀呀呀呀，说明白一点，就是找规律嘛，总结他们的关系是可重复的，可以用一个整体去表达。
上代码

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
        return true;
        return isMirror(root,root);
        
        
    }
    
    bool isMirror(TreeNode* p , TreeNode* q)
    {
        if(p==NULL&&q==NULL)
            return true;
        if(p==NULL||q==NULL)
            return false;

        return((p->val==q->val)&&isMirror(p->left,q->right)&&isMirror(p->right,q->left));
    }
};

5、完全二叉树的节点数

Leetcode 222
【题目】
给出一个完全二叉树，求出该树的节点个数。

说明：

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例:

输入:
1
/
2 3
/ \ /
4 5 6
输出: 6

我先用递归做的，应该二分查找和队列也可以，先贴上递归的方法

/**
 * 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:
    int countNodes(TreeNode* root) {
        if(root==NULL)
            return 0;
        if(root->left==NULL)
            return 1;
        else if(root->left!=NULL&&root->right==NULL)
            return 2;
        else
            return (countNodes(root->left)+countNodes(root->right))+1;

    }
};

6、平衡二叉树

Leetcode 110
【题目】
给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

3
/
9 20
/
15 7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

  1

  / \
 2   2
/ \

3 3
/
4 4
返回 false 。

用递归的方法，求出每层的层数

/**
 * 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:
    bool isBalanced(TreeNode* root) {
        if(root==NULL)
            return true;
        if(abs(height(root->left)-height(root->right))>1)
            return false;
        else
            return isBalanced(root->left)&&isBalanced(root->right);
        
    }

    int height(TreeNode* root)
    {
        if(root==NULL)
            return 0;
        else
            return max(height(root->left),height(root->right))+1;
    }
};

7、路径总和

Leetcode 112
【题目】
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

**示例: **

给定如下二叉树，以及目标和 sum = 22，
5
/
4 8
/ /
11 13 4
/ \
7 2 1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

用递归的方法完成

/**
 * 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:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==NULL)
            return false;
        if(root->left==NULL&&root->right==NULL)
            return root->val==sum;
        return hasPathSum(root->left,sum-root->val)||hasPathSum(root->right,sum-root->val);
        
    }
};

8、左叶子之和

Leetcode 404
【题目】
404. 左叶子之和
计算给定二叉树的所有左叶子之和。

示例：

3
/
9 20
/
15 7
在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

用递归的方法实现

/**
 * 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:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==NULL||root->left==NULL&&root->right==NULL)
            return 0;
        
        if(root->left==NULL)
        {
            return sumOfLeftLeaves(root->right);
        }
        if(root->left->left==NULL&&root->left->right==NULL)
            return root->left->val+ sumOfLeftLeaves(root->right);
        else
            return sumOfLeftLeaves(root->left)+sumOfLeftLeaves(root->right);
        

    }
};

或者用队列迭代，求出所有的左变的叶子节点

9、路径总和（II）

【题目】
给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

给定如下二叉树，以及目标和 sum = 22，
5
/
4 8
/ /
11 13 4
/ \ /
7 2 5 1
返回:
[
[5,4,11,2],
[5,8,4,5]

用深度优先的方法和递归的方法。

深度优先和广度优先要会。
深度优先用的是数组，其实也有点像栈，先入后出。
广度优先在在二叉树中常用在层序遍历中，先入先出。

上代码

/**
 * 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:
    vector<vector<int> > res;
    vector<int> temp;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        
        if(root==NULL)
            return res;
        DFS(root,sum);
        return res;
        
    }
    void DFS(TreeNode* root,int sum)
    {
        int sum_temp = sum-root->val;
        temp.push_back(root->val);
        if(sum_temp==0&&root->left==NULL&&root->right==NULL)
        {
            res.push_back(temp);
        }
        if(root->left)
        {
            DFS(root->left,sum_temp);
        }
        if(root->right)
        {
            DFS(root->right,sum_temp);
        }
        temp.pop_back();
    }
};

10、路径总和III

leetcode 437
【题目】
给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

示例：

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
10
/
5 -3
/ \
3 2 11
/ \
3 -2 1
返回 3。和等于 8 的路径有:

  1. 5 -> 3
  2. 5 -> 2 -> 1
  3. -3 -> 11

要理解分治的思想
重点是递归的终止条件和递归的过程。
这个题目用递归的思想，首先是每个节点都考虑和为sum的情况，然后相加

/**
 * 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:
    int pathSum(TreeNode* root, int sum)
    {
        if(root==NULL)
            return 0;
        int sum_node=0;
        sum_node=nodeSum(root,sum);
        if(root->left)
        {
            sum_node+=pathSum(root->left,sum);

        }
        if(root->right)
        {
            sum_node+=pathSum(root->right,sum);
        }
        return sum_node;
    }
    
    int nodeSum(TreeNode* root, int sum) {
        
        if(root==NULL)
            return 0;
        int num;
        if(root->val==sum)
            num=1;
        else 
            num=0;       
        int temp_num;
        temp_num=sum-root->val;
        return num+nodeSum(root->left,temp_num)+nodeSum(root->right,temp_num);


    }
};

11、二叉搜索树的公共祖先

Leetcode 235
【题目】
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
在这里插入图片描述

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

最主要的是要理解二叉搜索树的含义。公共祖先，说明是第一个在他们两个之间的数。这个要理解，然后要想到用递归的方法如何实现

/**
 * 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* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==NULL)
            return NULL;
        if(root->val<p->val&&root->val<q->val)
        return lowestCommonAncestor(root->right,p,q);
        if(root->val>p->val&&root->val>q->val)
        return lowestCommonAncestor(root->left,p,q);

        return root;
        
    }
};

12、二叉树的系列化和反序列化

Leetcode 297
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

示例:

你可以将以下二叉树：

1

/
2 3
/
4 5

序列化为 “[1,2,3,null,null,4,5]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-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 Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        //BFS 
        // Time Complexity: O(n)
        // Space Complexity: O(n)
        if(!root) //输入为空
            return "[null]";

            string ret="[";
            queue<TreeNode*>q;
            q.push(root);
            ret += to_string(root->val);//输入根结点
            while(!q.empty())
            {
                TreeNode* cur=q.front();
                q.pop();

                if(cur->left)
                {
                    ret += ","+to_string(cur->left->val);
                    q.push(cur->left);
                }
                else
                    ret += ",null";
                if(cur->right)
                {
                    ret+=","+to_string(cur->right->val);
                    q.push(cur->right);
                }
                else   ret += ",null";
            }
            return ret+"]";

        
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        vector <string> vec = get_vector(data);

        if(vec.size()==0||(vec.size()==1&&vec[0]=="null"))
            return NULL;
        
        TreeNode* root = new TreeNode(atoi(vec[0].c_str()));
        queue<TreeNode*>q;
        q.push(root);
        int index = 1 ;
        while(!q.empty())
        {
            TreeNode* cur = q.front();
            q.pop();

            assert(vec.size()-index>=2); //确保有两个及以上的结点
            if(vec[index]!="null") //不是空节点
            {
                cur->left = new TreeNode(atoi(vec[index].c_str()));
                q.push(cur->left);
            }
            index ++;

            if(vec[index]!="null")
            {
                cur->right = new TreeNode(atoi(vec[index].c_str()));
                q.push(cur->right);
            }
            index ++;
        }
        return root;
        
    }

    private:
    vector<string> get_vector(const string& data) //将字符串分隔转换成数组
    {
        string s = data.substr(1,data.size()-2)+","; //去除前后两个[]

        vector<string> res;

        int i = 0 ;
        while(i < s.size())
        {
            int comma = s.find(',',i); // i 位置之后第一次出现","的位置
            res.push_back(s.substr(i,comma-i));
            i = comma +1;

        }
        return res;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

13、将有序数组转化为二叉搜索树

在这里插入图片描述

二叉搜索树的中序遍历是升序序列，题目给定的数组是按照升序排序的有序数组，因此可以确保数组是二叉搜索树的中序遍历序列。

选择中间位置左边的数字作为根节点，则根节点的下标为 m i d = ( l e f t + r i g h t ) / 2 mid=(left+right)/2 mid=(left+right)/2，此处的除法为整数除法
在这里插入图片描述

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/solution/jiang-you-xu-shu-zu-zhuan-huan-wei-er-cha-sou-s-33/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

/**
 * 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* sortedArrayToBST(vector<int>& nums) {
        return help(nums,0,nums.size()-1);

    }
    TreeNode* help(vector<int>& nums, int left ,int right)
    {
        if(left>right)
            return NULL;
        int mid = left+(right-left)/2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = help(nums,left,mid-1);
        root->right = help(nums,mid+1, right);
        return root;
    }
};
墨墨非鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
202003-202009秋招刷题笔记.doc
08-31
文档标题和描述中提到的是2020年春季招聘期间的刷题笔记，重点在于算法题目和解题策略。从标签“刷题”可以看出，这是一份关于准备面试和提升编程技能的资料。以下是根据部分内容提炼出的一些核心知识点： 1. **双...
二叉树层次遍历：Queue+每一层一个NULL标记
学无止境
03-28 1866
题目描述 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 思路： 一个Queue+每一层一个NULL标记 即可。 每当队列头部检测到NULL时，代表上一层的遍历已经结束，此时队列中存放的是下一层的节点，所以要在队列尾部中再添加一个NULL。 /* struct TreeN
将数组转化为二叉树（递归与非递归）
fwk19840301的博客
12-22 499
class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 一、递归的实现 @Test public void testLevel() { Integer[] arr = new Integer[]{3,9,20,null,null,15,7}; TreeNo...
leetcode树之二叉树的操作
溪语流沙的博客
03-24 386
文章目录257、二叉树的所有路径404、左叶子之和671、二叉树中第二小的节点993、二叉树的堂兄弟节点1022、从根到叶的二进制之和 257、二叉树的所有路径 给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。 叶子节点 是指没有子节点的节点。 示例1： 输入：root = [1,2,3,null,5] 输出：["1->2->5","1->3"] 示例2： 输入：root = [1] 输出：["1"] 思路： 递归拼接所有路径 class Sol
二叉树(递归)
Sophon
02-19 6258
文章目录类型定义先序遍历中序遍历后序遍历层序遍历建树完整 类型定义 typedef char DataType; typedef struct BTreeNode { DataType data; struct BTreeNode * leftchild; struct BTreeNode * rightchild; }BinTreeNode; typedef BinTreeNode * ...
leetcode刷题（六）路径总和I、II、III
weixin_38368941的博客
05-13 6205
（一）112题题目地址：https://leetcode-cn.com/problems/path-sum/description/题目描述：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。解决方案：/** * Definition for a binary tree node. * struct TreeNode { *     int ...
leetcode分类-leetcode:leetcode刷题笔记
06-30
《LeetCode刷题笔记》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它按照问题类型进行了精心分类，涵盖了LeetCode这个在线编程平台上的众多挑战。LeetCode以其丰富的算法题目和实际编程问题，成为了提升...
labuladong的刷题笔记V2.0(力扣版)
03-17
labuladong是一位在编程界颇有影响力的博主，他的刷题笔记深受程序员喜爱，此次发布的V2.0版本更是对原有的内容进行了全面升级和优化。 这份14M的大文件涵盖了labuladong在LeetCode上刷题的深度解析和总结，包括但...
leetcode跳跃-leetcode:leetcode刷题笔记
06-30
leetcode刷题笔记 005-2. 最长回文子串 字符串+中心扩散 :star:010-3. 正则表达式匹配 动态规划 019-2. 删除链表的倒数第N个节点 链表+快慢指针 022-2. 括号生成 回溯法 :star:031-2. 下一个排列 数组+思维 034-2. ...
labuladong的刷题笔记V1.7(力扣版)
03-06
【labuladong的刷题笔记V1.7(力扣版)】是一份全面的算法练习资源，涵盖了从基础数据结构到复杂算法的各种题目，旨在提升编程者在职场和发展中的算法能力。以下是对其中涉及知识点的详细说明： 1. **基础数据结构**...
LeetCode112 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。
CourageKang的博客
09-07 4970
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *rig...
给定一个二叉树和一个目标和，判断该树中是否存在根结点到叶结点的路径
baobao1767640830的博客
05-26 2571
题目： 给定一个二叉树和一个目标和，判断该树中是否存在根结点到叶结点的路径，这条路径上所有结点值相加等于目标和。返回 true 或者 false。 1.了解二叉树的遍历框架 说到二叉树的遍历框架，很多人的脑海里立马蹦出来的就是前序、中序和后序遍历。但是机械地记住前中后序遍历没有太大意义，我们首先要掌握的是二叉树的递归思想 递归有两大要点： 反复调用自身 终止条件 二叉树结构上进行递归，则这两大要点变为： 递归调用自己两个子树 在叶结点处终止递归 调用子树的部分是重点。我们需要保证在子树上求解的是与原问题相同
#数据结构 给定一个二叉树和一个数值，判断该树中是否存在根节点到叶子结点的路径上所有结点值之和等于这个数值
qq_42368203的博客
06-10 1546
//给定一个二叉树和一个数值，判断该树中是否存在根节点到叶子结点的路径上所有结点值之和等于这个数值 bool hasPathSum(struct TreeNode* root, int sum){ if(rootNULL){ //空树返回错误 return false; }else if(root->leftNULL&&root->rightNULL&&root->valsum){ //当前结点为叶子节点并且数值相等返回ttrue return true
Leetcode 113 Path Sum II 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径
ata_123的专栏
07-24 3265
题目： 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。 说明:叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和sum = 22， 5 / \ 4 8 / / \ 11 13 4 /...
二叉树的常见笔试面试题
Nessie_zhao的博客
05-16 4866
在二叉树的基本操作里已经说明如何用递归的方法进行二叉树的遍历，那么如何用非递归的方法来进行二叉树的遍历呢，请看下文1.使用非递归方式进行二叉树的先序遍历![这里写图片描述](//img-blog.csdn.net/20180429152827371?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L05lc3NpZV96aGFv/font/5a6L5L2T/fontsiz...
112. 路径总和（Path Sum）
专心扫地
02-25 290
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明:叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 / / \ 11 13 4 ...
基于JAVA的厨艺交流平台（Vue.js+SpringBoot+MySQL）
08-01
基于Vue.js和SpringBoot的厨艺交流平台是一个功能丰富的在线社区，旨在为烹饪爱好者提供一个分享和学习烹饪技巧的平台。该平台分为管理后台和用户网页端，支持管理员和普通用户两种角色。管理后台提供对菜谱分类、菜谱信息、食材信息、商品信息和美食日志模块的全面管理功能，包括添加、编辑、删除和查询等操作。用户网页端则为用户提供了一个友好的界面，可以浏览和搜索各种菜谱，查看食材和商品信息，发表自己的美食日志，与其他用户互动交流。整个平台采用现代化的前端技术和后端框架，保证了良好的用户体验和高效的数据处理能力。 演示录屏：https://www.bilibili.com/video/BV1uz42197zu 配套教程：https://www.bilibili.com/video/BV1pW4y1P7GR
层次分析法数学建模论文.doc
最新发布
08-01
层次分析法数学建模论文
操作系统原理试卷及参考答案(A).doc
08-01
操作系统原理试卷及参考答案(A)
Labuladong二叉树递归课程与刷题资源
labuladong的刷题笔记V5.0是一份全面且深入的IT学习资料，主要聚焦于数据结构和算法的实践训练。...无论你是希望深入理解二叉树递归，还是寻求提高算法问题解决能力，这个刷题笔记都是一个不可或缺的学习资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值