leetcode257---Binary Tree Paths

本文介绍了一种使用深度优先搜索(DFS)的先序遍历方法来解决二叉树的所有根到叶路径查找问题。通过递归实现,文章详细解释了如何构建路径字符串并收集所有有效路径。

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

问题描述:

Given a binary tree, return all root-to-leaf paths.

For example, given the following binary tree:

   1
 /   \
2     3
 \
  5

All root-to-leaf paths are:

["1->2->5", "1->3"]

问题求解:

利用先序遍历,深度优先搜索方法求解。对此题而言,不适宜再采用中序遍历,因为如果path+"->"+to_string(root->val)的话,会出现”->1->2->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<string> binaryTreePaths(TreeNode* root) {
        vector<string> ret;
        //to_string()函数将int型转为string类型
        if(root) getPaths(ret, root, to_string(root->val));//先序,深度优先搜索
        return ret;
    }
    void getPaths(vector<string>& result, TreeNode* node, string path) {
        if(!node->left && !node->right){//到达叶子节点,便将当前路径加入到vector
            result.push_back(path);
            //return ;
        }
        if(node->left) getPaths(result, node->left, path+"->"+to_string(node->left->val));
        if(node->right) getPaths(result, node->right, path+"->"+to_string(node->right->val));
    }

};
### LeetCode 510: Binary Search Tree Iterator LeetCode Problem 510 is titled **Binary Search Tree Iterator**, which involves designing an iterator over a binary search tree (BST). The goal is to implement the `BSTIterator` class that initializes with the root of a BST and supports two operations: 1. `next()`: Returns the next smallest number in the BST. 2. `hasNext()`: Returns whether there exists a next smallest number. The solution should run in average O(1) time complexity per operation, using O(h) memory where h is the height of the tree[^1]. #### Approach Using Inorder Traversal To solve this problem efficiently, one can use an iterative inorder traversal approach leveraging a stack data structure. This method ensures that each node's value is processed in ascending order due to the properties of a BST. Here’s how it works: - Initialize a stack during construction (`__init__`) and populate it by traversing as far left from the given root as possible. - For every call to `next()`, pop the top element off the stack, then push all its right subtree nodes onto the stack following the same rule—traverse down the leftmost path starting at any new node added. - Use the `hasNext()` function simply to check if the stack still contains elements; if so, more values remain unprocessed. Below is Python code implementing such functionality: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class BSTIterator: def __init__(self, root: TreeNode): self.stack = [] self._leftmost_in_order(root) def _leftmost_in_order(self, root: TreeNode): while root: self.stack.append(root) root = root.left def next(self) -> int: top_node = self.stack.pop() if top_node.right: self._leftmost_in_order(top_node.right) return top_node.val def hasNext(self) -> bool: return len(self.stack) > 0 ``` This implementation guarantees both methods operate within acceptable performance bounds specified earlier[^2]. Additionally, since stacks only store references along paths leading toward potential future results rather than entire trees themselves, space usage remains proportional solely based on heights instead of total sizes involved here too!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值