def recurse(data, low, high):
if low > high:
return
else:
mid = low + (high - low) // 2
node = BSTNode(data[mid])
node.left = recurse(data, low, mid - 1)
node.right = recurse(data, mid + 1, high)
return node
def make_bst(array):
if not array:
return None
mid = len(array) // 2
root = BSTNode(array[mid])
if mid == 0:
return root
root.left = make_bst(array[:mid])
root.right = make_bst(array[mid + 1:])
return root
def get_node_recursive(leftp, rightp):
if (rightp - leftp) == 1:
return BSTNode(sorted_list[leftp])
if (rightp - leftp) == 0:
return None
middle = int((leftp + rightp) / 2)
node = BSTNode(sorted_list[middle])
node.left = get_node_recursive(leftp, middle)
node.right = get_node_recursive(middle + 1, rightp)
return node
def recursive(nodes):
middle_node = math.floor(((len(nodes) - 1) / 2))
new_root = BSTNode(nodes[middle_node])
if middle_node == 0:
return new_root
new_root.right = recursive(nodes[middle_node:])
new_root.left = recursive(nodes[:middle_node])
return new_root
def create_balanced_BST(arr):
if len(arr) == 0:
return None
middle = len(arr) // 2
new_root = BSTNode(data=arr[middle])
new_root.left = create_balanced_BST(arr[:middle])
new_root.right = create_balanced_BST(arr[middle + 1:])
return new_root
def making_tree(self):
node = BSTNode(self._field)
field1 = copy(self._field)
field2 = copy(self._field)
if self.status() == NOTHING:
cell = choice(Board.possible_cells(self._field))
cell2 = choice(Board.possible_cells(self._field))
field1.turn(cell)
field2.turn(cell2)
node.left = self.making_tree(field1)
node.right = self..making_tree(field2)
return node