LeetCode.938——Python二叉搜索树深度遍历（DFS）迭代及递归（栈）实现

二叉搜索树

二叉排序树，每个节点的 left < node < right

递归实现深度优先搜索

版本一

对于每个节点进行递归，并判断是否符合情况

注意 node 有可能为 None，所以要判断 if node

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def rangeSumBST(self, root: TreeNode, L: int, R: int) -> int:
    	def dfs(node):
    		if node:
    			# print(node.val)
    			if L <= node.val <= R:
    				self.ans += node.val
    			dfs(node.left)
    			dfs(node.right)
    	self.ans = 0
    	dfs(root)
    	return self.ans

版本二

分情况讨论

当 root 值在L 和R 之间，即左右子树都包含符合情况的节点时，如下，将左右根结点都加入递归

当 root 值在R 右边，即 L < R < node，L R 都在左子树，所以符合情况的也都在左子树，将左节点加入递归

在L 左边时同理 ，将右节点加入递归

class Solution:
    def rangeSumBST(self, root: TreeNode, L: int, R: int) -> int:
    	def dfs(node):
    		if node:
    			if L <= node.val <= R:
    				self.ans += node.val
    				dfs(node.left)
    				dfs(node.right)
    			elif R < node.val:
    				dfs(node.left)
    			else:
    				dfs(node.right)
    	self.ans = 0
    	dfs(root)
    	return self.ans

版本三

上面的情况可以进行合并，当 L < node 时，左面肯定有符合的，将左节点加入

同理， node > R 时，将右节点加入

与版本二效率一样，只不过表示方法不一样

class Solution:
    def rangeSumBST(self, root: TreeNode, L: int, R: int) -> int:
    	def dfs(node):
    		if node:
    			if L <= node.val <= R:
    				self.ans += node.val
    			if L <= node.val:
    				dfs(node.left)
    			if node.val <= R:
    				dfs(node.right)
    	self.ans = 0
    	dfs(root)
    	return self.ans

迭代实现深度优先搜索

采用栈来模拟

class Solution:
    def rangeSumBST(self, root: TreeNode, L: int, R: int) -> int:
    	stack = [root]
    	ans = 0
    	while stack:
    		node = stack.pop()
    		if node:
    			if L <= node.val <= R:
    				ans += node.val
    			if L <= node.val:
    				stack.append(node.left)
    			if node.val <= R:
    				stack.append(node.right)
    	return ans 

注意仍应该判断 node 因为 None.val 会报错