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]"))))