Task05:树

Seven7_Lu

已于 2022-02-23 20:49:39 修改

阅读量296

点赞数 1

文章标签：数据结构算法

于 2022-02-22 18:29:24 首次发布

本文链接：https://blog.csdn.net/qq_46521210/article/details/123070065

版权

1. 二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。

方法一：深度优先搜索

先递归的计算左子树和右子树的最大深度，然后在O(1)时间内计算出当前二叉树的最大深度。递归在访问到空节点时退出。

/**
 * 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 maxDepth(TreeNode* root) {
        if(root==nullptr){
            return 0;
        }
        return max(maxDepth(root->left), maxDepth(root->right))+1;
    }
};

时间复杂度：O(n)，其中n为二叉树节点的个数。每个节点在递归中只被遍历一次。

空间复杂度：O(height)，其中height表示二叉树的高度。递归函数需要栈空间，而占空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

方法二：广度优先搜索

计算二叉树的层数即为计算二叉树的最大深度，使用层次遍历，在遍历完一层的节点时，层数加1；使用队列进行辅助计算，队列用来存放当前层的所有节点，当节点的左右子树不为空时，出队列，并且存储该节点的左右子树。使用一个变量ans来维护拓展的次数，该二叉树的最大深度即为ans.

/**
 * 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 maxDepth(TreeNode* root) {
    if(root==nullptr){
        return 0;
    }
    queue<TreeNode*> Q;
    Q.push(root);
    int ans=0;
    while(!Q.empty()){
        int sz=Q.size();
        while(sz>0){
            TreeNode* node=Q.front();
            Q.pop();
            if(node->left){
                Q.push(node->left);
            }
            if(node->right){
                Q.push(node->right);
            }
            sz-=1;
        }
        ans+=1;
    }
    return ans;
    }
};

时间复杂度：O(n)，其中n为二叉树的节点数，每个节点只会被访问一次；

空间复杂度：取决于队列存储的元素数量，即二叉树的最大的宽度，最坏不会超过n，所以空间复杂度为O(n);

2. 将有序数组转化为二叉搜索树

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

        输入：nums = [-10,-3,0,5,9]
        输出：[0,-3,9,-10,null,5]
        解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案

方法：中序遍历，总是选择根节点左边的节点作为根节点。

分析：二叉搜索树的中序遍历是升序序列，题目给定的是按照升序排列的有序数组，因此可以确保数组是二叉搜索树的中序遍历序列。给定中序遍历的序列不可以唯一的确定一棵树的结构，即使要求高度平衡，也是无法唯一确定一棵树的结构，所以解题结果不唯一。

我们可以选择中间元素作为二叉搜索树的根节点，这样分给左右子树的数字个数相同或者只相差1，可以使得树保持平衡。如果数组的长度是奇数，则根节点的选择是唯一的，如果长度是偶数，则可以中间位置的左边或者是右边数字作为根节点，选择不同的数字作为根节点则创建的平衡二叉搜索树也是不同的。

确定平衡二叉树的根节点之后，其余的数字分别位于平衡二叉搜索树的左子树和右子树中，左子树和右子树分别也是平衡二叉搜索树，因此可以通过递归的方式创建平衡二叉搜索树。

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return helper(nums, 0, nums.size() - 1);
    }

    TreeNode* helper(vector<int>& nums, int left, int right) {
        if (left > right) {
            return nullptr;
        }

        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;

        TreeNode* root = new TreeNode(nums[mid]);
        root->left = helper(nums, left, mid - 1);
        root->right = helper(nums, mid + 1, right);
        return root;
    }
};

时间复杂度：O(n)，每个节点访问一次；

空间复杂度：O(logn)，递归调用栈的大小；

3. 二叉树的最小深度

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。

示例：

输入：root = [3,9,20,null,null,15,7]
输出：2

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

方法一：深度优先搜索

对于每一个非叶子节点，分别计算其左子树和右子树的最小叶节点深度。这样就将一个大问题转化为一个小问题，可以采用递归的方法。

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        if (root->left == nullptr && root->right == nullptr) {
            return 1;
        }

        int min_depth = INT_MAX;
        if (root->left != nullptr) {
            min_depth = min(minDepth(root->left), min_depth);
        }
        if (root->right != nullptr) {
            min_depth = min(minDepth(root->right), min_depth);
        }

        return min_depth + 1;
    }
};

时间复杂度：O(n)，n是树的节点数，对每个节点访问一次；

空间复杂度：O(logn)，logn为树的高度。主要取决于递归时栈空间的开销。

方法二：广度优先搜索

当碰到第一个叶子节点时，直接返回这个叶子节点的深度，广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。需要注意的是，在每一层结束的时候，depth+1，为了解决这个问题，采用了pair<TreeNode*, int>，int来标记每一层的深度。

class Solution {
public:
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        queue<pair<TreeNode *, int> > que;
        que.emplace(root, 1);
        while (!que.empty()) {
            TreeNode *node = que.front().first;
            int depth = que.front().second;
            que.pop();
            if (node->left == nullptr && node->right == nullptr) {
                return depth;
            }
            if (node->left != nullptr) {
                que.emplace(node->left, depth + 1);
            }
            if (node->right != nullptr) {
                que.emplace(node->right, depth + 1);
            }
        }

        return 0;
    }
};

时间复杂度：O(n)，其中n是节点数，对每一个节点访问一次；

空间复杂度：O(n)，主要取决于队列的开销，队列元素不会超过节点数；

4. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。叶子节点是指没有子节点的节点。

示例：

        输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
        输出：true
        解释：等于目标和的根节点到叶节点路径如上图所示。

    输入：root = [], targetSum = 0
    输出：false
    解释：由于树是空的，所以不存在根节点到叶子节点的路径。

方法一：广度优先搜索

首先我们可以想到使用广度优先搜索的方式，记录从根节点到当前节点的路径和，以防止重复计算。这样我们使用两个队列，分别存储将要遍历的节点，以及根节点到这些节点的路径和即可。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr){
            return false;
        }
        if(root->left==nullptr && root->right==nullptr){
            if(root->val==targetSum){
                return true;
            }else{
                return false;
            }
        }
        return hasPathSum(root->left, targetSum-root->val)||hasPathSum(root->right, targetSum-root->val);
    }
};

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(N)，其中 N是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。

方法二：递归

假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。

不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 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;
    }
    queue<TreeNode*> Q;
    queue<int> P;
    Q.push(root);
    P.push(root->val);
    while(!Q.empty() && !P.empty()){
        TreeNode* temp=Q.front();
        int sum=P.front();
        Q.pop();
        P.pop();
        if(temp->left==nullptr && temp->right==nullptr && sum==targetSum){
           return true; 
        }
        if(temp->left!=nullptr){
            Q.push(temp->left);
            P.push(sum+temp->left->val);
        }
        if(temp->right!=nullptr){
            Q.push(temp->right);
            P.push(sum+temp->right->val);
        }
    }
    return false;
    }
};

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(H)，其中 H是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为O(logN)。

5. 二叉搜索树迭代器

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。int next()将指针向右移动，然后返回指针处的数字。
注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

方法一：扁平化

我们可以直接对二叉搜索树做一次完全的递归遍历，获取中序遍历的全部结果并保存在数组中。随后，我们利用得到的数组本身来实现迭代器。

class BSTIterator {
private:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
    
    vector<int> arr;
    int idx;
public:
    BSTIterator(TreeNode* root): idx(0), arr(inorderTraversal(root)) {}
    
    int next() {
        return arr[idx++];
    }
    
    bool hasNext() {
        return (idx < arr.size());
    }
};

时间复杂度：初始化需要 O(n)的时间，其中 n为树中节点的数量。随后每次调用只需要 O(1)O的时间。

空间复杂度：O(n)，因为需要保存中序遍历的全部结果。

方法二：迭代

除了递归的方法外，我们还可以利用栈这一数据结构，通过迭代的方式对二叉树做中序遍历。此时，我们无需预先计算出中序遍历的全部结果，只需要实时维护当前栈的情况即可。

class BSTIterator {
private:
    TreeNode* cur;
    stack<TreeNode*> stk;
public:
    BSTIterator(TreeNode* root): cur(root) {}
    
    int next() {
        while (cur != nullptr) {
            stk.push(cur);
            cur = cur->left;
        }
        cur = stk.top();
        stk.pop();
        int ret = cur->val;
        cur = cur->right;
        return ret;
    }
    
    bool hasNext() {
        return cur != nullptr || !stk.empty();
    }
};

Seven7_Lu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Task05:树

1. 二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。方法一：深度优先搜索先递归的计算左子树和右子树的最大深度，然后在O(1)时间内计算出当前二叉树的最大深度。递归在访问到空节点时退出。/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *lef...
复制链接

扫一扫