分类 树 下的文章

完全二叉树的节点个数

问题描述

给出一个完全二叉树，求出该树的节点个数。

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

示例:

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

输出: 6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-complete-tree-nodes

思路

基本思路就是用深度优先搜索遍历一次二叉树

题解

/**
 * 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<int> res;
    int count=0;
    int countNodes(TreeNode* root) {
        dfs(root);
        return count;
    }
    void dfs(TreeNode *node){
        if(node== nullptr) return ;
        count++;
        if(node->left!= nullptr) dfs(node->left);
        if(node->right!= nullptr) dfs(node->right);
    }
};

二叉树的右视图

问题描述

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-right-side-view

思路

和层次遍历的思路是一样的

  • 按层将二叉树存到vector<vector<int>> vec中，此处和二叉树的层次遍历不同的是，本题从每层的右侧开始存。
    当然也可以从每层的左边开始遍历，用reverse反转一下就可以了。
  • 将veci存到vector<int> ret中。
  • 最后return ret即可。

题解

/**
 * 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>> vec;
    vector<int> ret;

    vector<int> rightSideView(TreeNode *root) {
        dfs(root, 0);
        int n = vec.size();
        if (n == 0) return ret;
        for(int i=0;i<n;i++){
            ret.push_back(vec[i][0]);
        }
        return  ret;
    }

    void dfs(TreeNode *node, int level) {
        if (node == nullptr) return;
        if (level + 1 > vec.size()) vec.push_back(vector<int>());
        vec[level].push_back(node->val);
        dfs(node->right, level + 1);
        dfs(node->left, level + 1);
    }
};

二叉搜索树迭代器

问题描述

实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。

调用 next() 将返回二叉搜索树中的下一个最小的数。

示例：

二叉搜索树迭代器.png

BSTIterator iterator = new BSTIterator(root);
iterator.next(); // 返回 3
iterator.next(); // 返回 7
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 9
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 15
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 20
iterator.hasNext(); // 返回 false
 
提示：
next() 和 hasNext() 操作的时间复杂度是 O(1)，并使用 O(h) 内存，其中 h 是树的高度。
你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 中至少存在一个下一个最小的数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search-tree-iterator

思路

复杂度没满足要求...

  • 因为二叉树是搜索二叉树，所以中序遍历的顺序即为从小到大的顺序。
  • 设置一个全局变量的指针，指向下一个最小的数。
  • 对于bool hasNEXT（）这一函数，当指针指向vec最后一个元素的下一个时，才return false，否则返回true即可。

题解

struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };

class BSTIterator {
private:
    vector<int> vec;
    int location;
public:
    void inorder(TreeNode *node){
        if(node == nullptr){
            return ;
        }
        inorder(node->left);
        vec.push_back(node->val);
        inorder(node->right);
    }
    BSTIterator(TreeNode* root) {
        inorder(root);
        location=0;
    }

    /** @return the next smallest number */
    int next() {
        if(location<vec.size()){
            return vec[location++];
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        if(location>=vec.size()){
            return false;
        } else return true;
    }
};

路径总和 II

问题描述

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

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

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-sum-ii

思路

深搜

  • 当节点是叶子节点时，就不用向下继续搜索了。
  • 非叶子节点，左右子树都遍历完以后，就将其从vector中弹出。

详细实现可以在题解中查看，很容易理解的。

题解

class Solution {
public:
    vector<int> vec;
    vector<vector<int>> ret;

    void dfs(TreeNode *node, int sum, int target) {
        if (node->left == nullptr && node->right== nullptr) {
            vec.push_back(node->val);
            sum+=node->val;
            if (sum== target) {
                ret.push_back(vec);
            }
            vec.pop_back();
            return;
        }
        vec.push_back(node->val);
        if(node->left!= nullptr)dfs(node->left, sum + node->val, target);
        if(node->right!= nullptr) dfs(node->right, sum + node->val, target);
        vec.pop_back();
    }

    vector<vector<int>> pathSum(TreeNode *root, int sum) {
        if (root != nullptr) {
            dfs(root, 0, sum);
        }
        return ret;
    }
};

二叉树展开为链表

问题描述

给定一个二叉树，原地将它展开为链表。

例如，给定二叉树

   1
   / \
  2   5
 / \   \
3   4   6

将其展开为：

1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list

思路

题目描述中是将二叉树展开为链表，但是函数返回值是void，所以题目真实的要求应该是将一个二叉树按中序遍历的顺序展开为一个只有右子树的二叉树。

  • 将二叉树按照中序遍历的顺序存储到一个vector<TreeNode*>中。
  • TreeNode *p=root,即从root所在的节点开始，其左子树为nullptr，右子树为vec[i]（注意i是从1开始的），然后，p=p->right

题解

class Solution {
public:
    vector<TreeNode*> vec;
    void flatten(TreeNode* root) {
        TreeNode *p=root;
        dfs(root);
        for(int i=1;i<vec.size();i++){
            p->left= nullptr;
            p->right=vec[i];
            p=p->right;
        }
   }
   void dfs(TreeNode *node){
        if(node== nullptr) return;
        vec.push_back(node);
        dfs(node->left);
        dfs(node->right);
    }
};
  1. 1
  2. 2
  3. 3
  4. 4