def build_tree():
val = vals.popleft()
if val != 'null':
node = TreeNode(int(val))
node.left = build_tree()
node.right = build_tree()
return node
else:
return None
def helper(l, r):
nonlocal head # 将head声明为外层变量
if l > r: return None
mid = (l + r) // 2
left = helper(l, mid - 1)
root = TreeNode(head.val)
root.left = left
head = head.next
root.right = helper(mid + 1, r)
return root
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
if not head: return None
if not head.next: return TreeNode(head.val)
slow = self.find_mid_node(head)
root = TreeNode(slow.val)
root.left, root.right = self.sortedListToBST(
head), self.sortedListToBST(slow.next)
return root
def helper(n):
if n == 1:
return [TreeNode(0)]
i, res = 1, []
while i < n - 1:
left, right = helper(i), helper(n - 1 - i)
for x in left:
for y in right:
root = TreeNode(0)
root.left = x
root.right = y
res.append(root)
i += 2
return res
def insertIntoBST(self, root, val):
"""
:type root: TreeNode
:type val: int
:rtype: TreeNode
"""
temp = root
while temp:
if temp.val > val:
if not temp.left:
temp.left = TreeNode(val)
break
temp = temp.left
else:
if not temp.right:
temp.right = TreeNode(val)
break
temp = temp.right
return root
def insertIntoBST(self, root, val):
"""
:type root: TreeNode
:type val: int
:rtype: TreeNode
"""
if not root: return TreeNode(val)
if root.val > val:
root.left = self.insertIntoBST(root.left, val)
else:
root.right = self.insertIntoBST(root.right, val)
return root
def insert(self, v):
"""
:type v: int
:rtype: int
"""
parent = self.deque[0]
self.deque.append(TreeNode(v))
if not parent.left:
parent.left = self.deque[-1]
else:
parent.right = self.deque[-1]
self.deque.popleft()
return parent.val
class MissingnessDT:
def __init__(self, passiveData, activeDataSymptom, activeDataSleep,
startDate):
self.passive = passiveData
self.activeSymptom = activeDataSymptom
self.activeSleep = activeDataSleep
self.startDate = datetime.datetime.strptime(startDate, '%d/%m/%Y')
def constructDecisionTree(self):
def evalBattery(data):
batteryEvalStart = data[['timestamp', 'battery']].values[0]
batteryEvalEnd = data[['timestamp', 'battery']].values[4]
if batteryEvalStart[1] in '-' or float(batteryEvalStart[1]) > 1:
return (False, data)
else:
dateStart = datetime.datetime.strptime(batteryEvalStart[0],
'%Y-%m-%d %H:%M')
dateEnd = datetime.datetime.strptime(batteryEvalEnd[0],
'%Y-%m-%d %H:%M')
elapsedTime = dateEnd - dateStart
elapsedMin = elapsedTime.total_seconds() / 60
return (True, batteryEvalStart[0])
def evalHeartRate(data):
heartEval = data[['timestamp', 'heart_Minutes']].values
if heartEval[0][1] not in '-':
return (False, data)
else:
hasNotValue = True
for i in range(1, len(heartEval)):
if heartEval[i][1] not in '-':
hasNotValue = False
if not hasNotValue:
break
return (hasNotValue, heartEval[0][0])
def evalTransmissionFailure(data):
tfTime = data['timestamp'].values
tfEval = data[[
'steps', 'light', 'FAM', 'LAM', 'VAM', 'awake_count'
]].values
tfEvalFlat = [val for sublist in tfEval for val in sublist]
hasNotValue = True
for i in range(0, len(tfEvalFlat)):
if tfEvalFlat[i] not in '-':
hasNotValue = False
if not hasNotValue:
break
return (hasNotValue, tfTime[0])
def finaLeafPass(data):
time = data.values[0][0]
return (True, time)
def channelThrough(d):
return (True, d)
def simFailure(d):
return (False, d)
leaf0 = TreeLeaf(name='Not Charged', evalMethod=evalBattery)
leaf1 = TreeLeaf(name='Not Worn', evalMethod=evalHeartRate)
leaf2 = TreeLeaf(name='Transmission Failure',
evalMethod=evalTransmissionFailure)
leaf3 = TreeLeaf(name='No Missingness', evalMethod=finaLeafPass)
node2 = TreeNode(name='Leaf2<>Leaf3',
children=[leaf2, leaf3],
evalMethod=channelThrough)
node1 = TreeNode(name='Leaf1<>Node2',
children=[leaf1, node2],
evalMethod=channelThrough)
self.root = TreeNode(name='Root[Leaf0<>Node1]',
children=[leaf0, node1],
evalMethod=channelThrough)
def run(self):
for i in range(self.passive.index[0],
self.passive.index[round(len(self.passive.index) -
10)]):
self.root.invoke(self.passive.loc[i:(i + 10)])
self.result = self.root.retrieveLeaves()
def formatMissingness(self):
self.missingness = {'count': dict(), 'daily': dict()}
for category in self.result:
self.missingness['count'][category.name] = len(category.result)
self.missingness['daily'][category.name] = self.countDailyTreeLeaf(
category)
self.missingness['count']['symptom'] = len(
self.activeSymptom['datetime'].values)
self.missingness['daily']['symptom'] = self.countDailyActive(
self.activeSymptom['datetime'].values)
self.missingness['count']['sleep'] = len(
self.activeSleep['datetime'].values)
self.missingness['daily']['sleep'] = self.countDailyActive(
self.activeSleep['datetime'].values)
print(self.missingness)
def countDailyTreeLeaf(self, category):
idxEnd = len(self.passive['timestamp'].values) - 1
dayEnd = datetime.datetime.strptime(
self.passive['timestamp'].values[idxEnd], '%Y-%m-%d %H:%M')
dayStart = datetime.datetime.strptime(
self.passive['timestamp'].values[0], '%Y-%m-%d %H:%M')
delta = dayEnd - dayStart
dailyCount = [0] * delta.days
if len(category.result) > 0:
evalDay = datetime.datetime.strptime(category.result[0],
'%Y-%m-%d %H:%M')
dayIdx = 0
for dateTime in category.result:
currentDay = datetime.datetime.strptime(
dateTime, '%Y-%m-%d %H:%M')
if evalDay.date() == currentDay.date():
dailyCount[dayIdx] += 1
else:
evalDay = currentDay
dayIdx += 1
if dayIdx < len(dailyCount):
dailyCount[dayIdx] += 1
else:
break
return dailyCount
def countDailyActive(self, dates):
dates = self.activeSymptom['datetime'].values
dailyCount = [0] * 56
dayIdx = 0
evalDay = self.startDate
for dateTime in dates:
currentDay = datetime.datetime.strptime(dateTime, '%Y-%m-%d %H:%M')
if evalDay.date() == currentDay.date():
dailyCount[dayIdx] += 1
else:
evalDay = currentDay
dayIdx += 1
if dayIdx < len(dailyCount):
dailyCount[dayIdx] += 1
else:
break
return dailyCount
def __str__(self):
rendered = '\nMissingness Summary (Count)\n'
for key in self.missingness['count'].keys():
rendered += '{}: {}\n'.format(str.capitalize(key),
self.missingness['count'][key])
return rendered
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
vals = collections.deque(data.split())
def build_tree():
val = vals.popleft()
if val != 'null':
node = TreeNode(int(val))
node.left = build_tree()
node.right = build_tree()
return node
else:
return None
return build_tree()
# Your Codec object will be instantiated and called as such:
codec = Codec()
t = TreeNode(5)
t.left = TreeNode(2)
t.left.right = TreeNode(4)
t.right = TreeNode(9)
root = codec.deserialize(codec.serialize(t))
Tree().front_recursion(root)
from tools import TreeNode
class Solution:
def findTilt(self, root: TreeNode) -> int:
if root is None:
return 0
result = [0]
self.getSum(root, result)
return result[0]
def getSum(self, root, num):
sumLeft = 0
sumRight = 0
if root.left is not None:
sumLeft = self.getSum(root.left, num)
if root.right is not None:
sumRight = self.getSum(root.right, num)
num[0] = num[0] + abs(sumLeft - sumRight)
return sumLeft + sumRight + root.val
root = TreeNode.stringToTreeNode("[1,2,3]")
print(Solution().findTilt(root))
def helper(l, r):
if l > r: return None
mid = (l + r) // 2
root = TreeNode(vals[mid])
root.left, root.right = helper(l, mid - 1), helper(mid + 1, r)
return root
from typing import List
from tools import TreeNode
class Solution:
def largestValues(self, root: TreeNode) -> List[int]:
if root is None:
return []
result = []
queue = [root]
while len(queue) > 0:
maxValue = None
length = len(queue)
for i in range(length):
node = queue.pop(0)
if maxValue is None or maxValue < node.val:
maxValue = node.val
if node.left is not None:
queue.append(node.left)
if node.right is not None:
queue.append(node.right)
result.append(maxValue)
return result
print(Solution().largestValues(TreeNode.stringToTreeNode("[1,3,2,5,3,9]")))
from typing import List
from tools import TreeNode
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if root is None:
return []
result = []
queue = [root]
while len(queue) > 0:
length = len(queue)
temp = [0] * length
for i in range(length):
node = queue.pop(0)
temp[i] = node.val
if node.left is not None:
queue.append(node.left)
if node.right is not None:
queue.append(node.right)
result.append(temp)
return result
print(Solution().levelOrder(
TreeNode.stringToTreeNode("[3,9,20,null,null,15,7]")))
def helper(list):
if not list: return None
mid = len(list) // 2
root = TreeNode(list[mid])
root.left, root.right = helper(list[:mid]), helper(list[mid + 1:])
return root
:type root: TreeNode
:type target: TreeNode
:type K: int
:rtype: List[int]
"""
conn = collections.defaultdict(set)
def connect(root):
if not root: return
if root.left:
conn[root.val].add(root.left.val)
conn[root.left.val].add(root.val)
if root.right:
conn[root.val].add(root.right.val)
conn[root.right.val].add(root.val)
connect(root.left)
connect(root.right)
connect(root)
res = [target.val]
seen = set(res)
for i in range(K):
res = [y for x in res for y in conn[x] if y not in seen]
seen |= set(res)
return res
s = Solution()
T = Tree().creat_tree("1 null null")
print(s.distanceK(T, TreeNode(1), 3))
from tools import TreeNode
class Solution:
def hasPathSum(self, root: TreeNode, sum: int) -> bool:
if root is None:
return False
return self._addValEqual(root, 0, sum)
def _addValEqual(self, node, counter, sum):
if node is None:
return counter == sum
counter += node.val
haveChild = False
if node.left is not None:
haveChild = True
if self._addValEqual(node.left, counter, sum):
return True
if node.right is not None:
haveChild = True
if self._addValEqual(node.right, counter, sum):
return True
return False if haveChild else counter == sum
print(Solution().hasPathSum(TreeNode.stringToTreeNode("[0,1,1]"), 0))
def constructDecisionTree(self):
def evalBattery(data):
batteryEvalStart = data[['timestamp', 'battery']].values[0]
batteryEvalEnd = data[['timestamp', 'battery']].values[4]
if batteryEvalStart[1] in '-' or float(batteryEvalStart[1]) > 1:
return (False, data)
else:
dateStart = datetime.datetime.strptime(batteryEvalStart[0],
'%Y-%m-%d %H:%M')
dateEnd = datetime.datetime.strptime(batteryEvalEnd[0],
'%Y-%m-%d %H:%M')
elapsedTime = dateEnd - dateStart
elapsedMin = elapsedTime.total_seconds() / 60
return (True, batteryEvalStart[0])
def evalHeartRate(data):
heartEval = data[['timestamp', 'heart_Minutes']].values
if heartEval[0][1] not in '-':
return (False, data)
else:
hasNotValue = True
for i in range(1, len(heartEval)):
if heartEval[i][1] not in '-':
hasNotValue = False
if not hasNotValue:
break
return (hasNotValue, heartEval[0][0])
def evalTransmissionFailure(data):
tfTime = data['timestamp'].values
tfEval = data[[
'steps', 'light', 'FAM', 'LAM', 'VAM', 'awake_count'
]].values
tfEvalFlat = [val for sublist in tfEval for val in sublist]
hasNotValue = True
for i in range(0, len(tfEvalFlat)):
if tfEvalFlat[i] not in '-':
hasNotValue = False
if not hasNotValue:
break
return (hasNotValue, tfTime[0])
def finaLeafPass(data):
time = data.values[0][0]
return (True, time)
def channelThrough(d):
return (True, d)
def simFailure(d):
return (False, d)
leaf0 = TreeLeaf(name='Not Charged', evalMethod=evalBattery)
leaf1 = TreeLeaf(name='Not Worn', evalMethod=evalHeartRate)
leaf2 = TreeLeaf(name='Transmission Failure',
evalMethod=evalTransmissionFailure)
leaf3 = TreeLeaf(name='No Missingness', evalMethod=finaLeafPass)
node2 = TreeNode(name='Leaf2<>Leaf3',
children=[leaf2, leaf3],
evalMethod=channelThrough)
node1 = TreeNode(name='Leaf1<>Node2',
children=[leaf1, node2],
evalMethod=channelThrough)
self.root = TreeNode(name='Root[Leaf0<>Node1]',
children=[leaf0, node1],
evalMethod=channelThrough)
from tools import TreeNode
class Solution:
def isValidBST(self, root: TreeNode) -> bool:
if root is None:
return True
return self.dfs(root, None) is not None
def dfs(self, root, before):
last = None
if root.left is not None:
temp = self.dfs(root.left, before)
if temp is None or temp >= root.val:
return None
if before is None or root.val > before:
last = root.val
else:
return None
if root.right is not None:
temp = self.dfs(root.right, last)
if temp is None or temp <= root.val:
return None
last = temp
return last
print(Solution().isValidBST(
TreeNode.stringToTreeNode("[5,1,4,null,null,3,6]")))
from tools import TreeNode
class Solution:
def pruneTree(self, root: TreeNode) -> TreeNode:
if root is None:
return None
self.doPruneTree(root)
return root
def doPruneTree(self, root):
flag = False
if root.left is not None:
x = self.doPruneTree(root.left)
if not x:
root.left = None
flag = flag or x
if root.right is not None:
x = self.doPruneTree(root.right)
if not x:
root.right = None
flag = flag or x
return flag or (root.val == 1)
print(TreeNode.treeNodeToString(Solution().pruneTree(TreeNode.stringToTreeNode("[1,null,0,0,1]"))))
