self.preOrderTraversal(root.left, dq)
dq.appendleft(root)
self.preOrderTraversal(root.right, dq)
def hasNext(self):
"""
:rtype: bool
"""
return len(self.nodes) > 0
def next(self):
"""
:rtype: int
"""
return self.nodes.pop().val
# Your BSTIterator will be called like this:
# i, v = BSTIterator(root), []
# while i.hasNext(): v.append(i.next())
nodes = TreeNode.fromArray([4,2,6,1,3,5,7])
v = BSTIterator(nodes[0])
while v.hasNext():
n = v.next()
print(n)
# self.left = None
# self.right = None
from TreeNode import TreeNode
from collections import deque
class Solution(object):
def kthSmallest(self, root, k):
"""
:type root: TreeNode
:type k: int
:rtype: int
"""
nodes = deque()
self.preOrderTraversal(root, nodes)
for n in nodes:
print(n.val)
return nodes[len(nodes)-k].val
def preOrderTraversal(self,root, dq):
if not root: return
self.preOrderTraversal(root.left, dq)
dq.appendleft(root)
self.preOrderTraversal(root.right, dq)
s = Solution()
nodes = TreeNode.fromArray([1,None,2])
print(s.kthSmallest(nodes[0], 1))
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
# Level order traversal, get rightmost node on each level
class Solution(object):
def rightSideView(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
levels = list()
self.levelOrderTraversal(root, 0, levels)
return [level[len(level)-1] for level in levels]
def levelOrderTraversal(self,root, depth, levels):
if not root: return
if depth >= len(levels): levels.append([])
levels[depth].append(root.val)
if root.left: self.levelOrderTraversal(root.left, depth+1, levels)
if root.right: self.levelOrderTraversal(root.right, depth+1, levels)
head = TreeNode.fromArray([1,2,3,None,5,None,None])
s = Solution()
for n in s.rightSideView(head):
print (n)
if depth >= len(levels): levels.append(None)
if not root: return (False, False)
hasP = False
hasQ = False
if root == p: hasP = True
if root == q: hasQ = True
leftHasP, leftHasQ = self.findPQ(root.left, p, q, depth+1, levels)
rightHasP, rightHasQ = self.findPQ(root.right, p, q, depth+1, levels)
pp = hasP or leftHasP or rightHasP
qq = hasQ or leftHasQ or rightHasQ
if pp and qq: levels[depth] = root
return (pp,qq)
def betterOne(self, root, p, q):
if root in (None, p, q): return root
left, right = (self.lowestCommonAncestor(kid, p, q) for kid in (root.left, root.right))
return root if left and right else left or right
nodes = TreeNode.fromArray([3,5,1,6,2,0,8,None,None,7,4])
# for node in nodes:
# if node: print(node.val)
s = Solution()
n5 = nodes[1]
n1 = nodes[2]
n4 = nodes[10]
# print(s.lowestCommonAncestor(nodes[0], n5, n1).val)
print(s.lowestCommonAncestor(nodes[0], n5, n4).val)