Leetcode - Episode 15 - Three Tree Qs (3 x E)
January 15, 2019 in Algorithms
I felt like it was time to knock some of these tree questions out. I find that solving tree questions in Python leads to simple, elegant code.
I went over Heap’s Algorithm for solving permutation problems earlier. It hasn’t fully clicked with me yet though. More studying is required — as well as checking out alternative solutions. Heap’s feels a little heavy-handed to me.
226. Invert Binary Tree
Problem: Invert a binary tree.
I like the check I use here before I invert — if node.left or node.right:
. It’s instantly obvious that it will work for all three siutations, two leafs, one leaf, None.
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def invertTree(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
def recurse(node):
if node.left or node.right:
node.left, node.right = node.right, node.left
if node.left:
recurse(node.left)
if node.right:
recurse(node.right)
return
if root:
recurse(root)
return root
This problem is a little bit of a meme. I expected it to be harder than it was but I have been revising tree algorithms recently..
Runtime complexity: O(n)
.
Spacetime complexity: O(n)
.
590. N-ary Tree Postorder Traversal
Problem: Return the postorder traversal of a tree’s values.
To think about this in another way, return the values as you would read the tree from the bottom up line by line.
"""
# Definition for a Node.
class Node(object):
def __init__(self, val, children):
self.val = val
self.children = children
"""
class Solution(object):
def postorder(self, root):
"""
:type root: Node
:rtype: List[int]
"""
vals = []
queue = []
if root:
queue.append(root)
while queue:
cur = queue.pop()
vals.append(cur.val)
queue.extend(cur.children)
return vals[::-1]
I recently learned (or, confirmed) that Python doesn’t create new memory when slicing or creating an iterator, e.g. [1,2][::-1]
/ reversed([1,2])
. It seems obvious now that I think about it.
Runtime complexity: O(n)
.
Space complexity: O(n)
.
589. N-ary Tree Preorder Traversal
Problem: Return the preorder traversal of a tree’s values.
Another way to think about preorder traversal is Depth-First-Search order.
"""
# Definition for a Node.
class Node(object):
def __init__(self, val, children):
self.val = val
self.children = children
"""
class Solution(object):
def preorder(self, root):
"""
:type root: Node
:rtype: List[int]
"""
dfs_order = []
def recurse(node):
dfs_order.append(node.val)
if node.children is not None:
for i in range(0, len(node.children)):
recurse(node.children[i])
if root:
recurse(root)
return dfs_order
I think this is a fairly terse but understandable solution but you can only make DFS so complicated.
Runtime complexity: O(n)
.
Spacetime complexity: O(n)
.
Comments or questions? I enjoy talking with readers over email.
Email newsletter 📧
I write about code. Get my posts, projects, and personal updates straight to your inbox!