def help(self, left, right, nums):
if left > right:
return None
mid = (left + right) / 2
root = TreeNode(nums[mid])
root.left = self.help(left, mid - 1, nums)
root.right = self.help(mid + 1, right, nums)
return root
def stump():
labels = ['zero', 'one']
left = TreeNode(2, 2, None, None, labels)
right = TreeNode(2, 2, None, None, labels)
stump = TreeNode(2, 2, left, right, ['1-sigma', 'sigma'])
stump.beta = nn.Parameter(torch.Tensor([[1], [0]]))
stump.phi = nn.Parameter(torch.Tensor([0]))
left.beta = nn.Parameter(torch.Tensor([1, 0]))
right.beta = nn.Parameter(torch.Tensor([0, 1]))
return stump
def _testSolution(self, skip=(), assertions=(), deep=3):
node_count = pow(2, deep)
node_queue = Queue.Queue(node_count)
root_queue = Queue.Queue(node_count / 2)
# Generate the tree
nodes = [TreeNode(x) for x in xrange(1, node_count)]
root_queue.put(nodes[0])
for node in nodes[1:]:
node_queue.put(node)
while not node_queue.empty():
root = root_queue.get()
root.left = node_queue.get()
root.right = node_queue.get()
root_queue.put(root.left)
root_queue.put(root.right)
if root.left.val in skip:
root.left = None
if root.right.val in skip:
root.right = None
# Solution
self.solution.connect(nodes[0])
# Assertion
for node, length in assertions:
self.assertLinkedList(nodes[node - 1], length)
def binary_tree_constructor(node_list: List[int]) -> TreeNode:
"""Returns root of tree constructed from List[int]."""
root = TreeNode(node_list[0])
current = [root]
ptr = 1
while ptr < len(node_list):
next_node = []
for n in current:
if node_list[ptr]:
n.left = TreeNode(node_list[ptr])
next_node.append(n.left)
ptr += 1
if node_list[ptr]:
n.right = TreeNode(node_list[ptr])
next_node.append(n.right)
ptr += 1
current = next_node
return root
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if len(nums) == 0:
return None
if len(nums) == 1:
return TreeNode(nums[0])
return self.help(0, len(nums) - 1, nums)
def get_map_results_faster(prefix, query_chunks):
node = TreeNode.follow_chunks(prefix, query_chunks)
query = node.get_most_popular_child_chunk_by_country2()
results = []
for country, text, count in query:
results.append({
'text': text,
'country': country,
'count': count
})
return {
'words': results
}
def get_map_results(prefix, query_chunks):
node = TreeNode.follow_chunks(prefix, query_chunks)
countries = node.get_top_chunk_countries_for_children()
words = []
for country in countries:
word, count = node.get_most_popular_child_chunk_in(country)
words.append({
'text': word,
'country': country,
'count': count
})
return {
'words': words
}
def create_item():
parent_node = TreeNode.query.filter(TreeNode.parent_id == 1).first()
if request.method == 'POST':
title = request.form['name']
body = request.form['body']
try:
item = TreeNode(name=title, parent=parent_node, body=body)
db.session.add(item)
db.session.commit()
except:
print('Something wrong')
return redirect(url_for('tree.index'))
form = ItemForm()
return render_template('tree/create_item.html', form=form)
def _testSolution(self, deep):
node_count = pow(2, deep)
node_queue = Queue.Queue(node_count)
root_queue = Queue.Queue(node_count / 2)
# Generate the tree
nodes = [TreeNode(x) for x in xrange(1, node_count)]
root_queue.put(nodes[0])
for node in nodes[1:]:
node_queue.put(node)
while not node_queue.empty():
root = root_queue.get()
root.left = node_queue.get()
root.right = node_queue.get()
root_queue.put(root.left)
root_queue.put(root.right)
# Solution
self.solution.connect(nodes[0])
# Assertion
for level in xrange(deep):
self.assertLinkedList(nodes[pow(2, level) - 1], pow(2, level))
from app import db
from models import TreeNode
db.create_all()
node = TreeNode(name='Programming language', body=None)
TreeNode(name='Dynamically typed languages', parent=node, body=None)
TreeNode(name='Python',
parent=node.children['Dynamically typed languages'],
body='some text')
subnode = TreeNode(name='JavaScript',
parent=node.children['Dynamically typed languages'],
body='some text')
db.session.add(node)
db.session.commit()
print(node.dump())
def get_example_tweet(prefix, query_chunks, country_name):
"""Finds an example tweet for the given query"""
node = TreeNode.follow_chunks(prefix, query_chunks)
return TweetChunk.get_example_tweet(country_name, node)
:type root: TreeNode
:rtype: List[List[int]]
"""
result = []
if root is None:
return result
stack = [root]
while len(stack) != 0:
t = []
tt = []
for node in stack:
t.append(node.val)
if node.left is not None:
tt.append(node.left)
if node.right is not None:
tt.append(node.right)
stack = tt
result.insert(0, t)
return result
if __name__ == '__main__':
s = Solution()
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.right.right = TreeNode(5)
print s.levelOrderBottom(root)