def add(self, item):
"""Adds item to the tree."""
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
node = self._root
while True:
# New item is less, go left until spot is found
if item < node.data:
if node.left is None:
node.left = BSTNode(item)
break
else:
node = node.left
# New item is greater or equal,
# go right until spot is found
elif node.right is None:
node.right = BSTNode(item)
break
else:
node = node.right
# End of recurse
self._size += 1
def add(self, item):
"""Adds item to the tree."""
node = self._root
# Helper function to search for item's position
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
while node != None:
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
break
else:
node = node.left
# New item is greater or equal,
# go right until spot is found
elif node.right == None:
node.right = BSTNode(item)
break
else:
node = node.right
self._size += 1
def add(self, value):
"""
Adds value to the tree.
"""
if self.isEmpty():
self._root = BSTNode(value)
self._size += 1
return
curr_node = self._root
while True:
if value < curr_node.data:
if curr_node.left is None:
curr_node.left = BSTNode(value)
self._size += 1
break
else:
curr_node = curr_node.left
else:
if curr_node.right is None:
curr_node.right = BSTNode(value)
self._size += 1
break
else:
curr_node = curr_node.right
def add(self, item):
"""Adds item to the tree."""
curr = self._root
parent = None
if curr is None:
self._root = BSTNode(item)
self._size += 1
return
while curr:
parent = curr
if item < curr.data:
curr = curr.left
else:
curr = curr.right
if item < parent.data:
parent.left = BSTNode(item)
else:
parent.right = BSTNode(item)
self._size += 1
def replace_ordered_list(self, llist):
"""Replace elements in BST with already ordered list"""
self._size = 0
self._root = BSTNode(llist[0])
current_node = self._root
for idx in range(1, len(llist)):
current_node.right = BSTNode(llist[idx])
current_node = current_node.right
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 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 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 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 recurse(node):
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
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 recurse(node):
"""
Helper function to search for item's position.
"""
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
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
def recurse(node):
# New item is less, go left until spot is found
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
# New item is greater or equal,
# go right until spot is found
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
def process(node):
board = node.data
if not board or not board.is_free_cell():
return
if board.check_status() is not None:
return
list2 = [[1, 0], [1, 2], [0, 1], [2, 1]]
list1 = [[2, 2], [0, 0], [0, 2], [2, 0], [1, 1]]
retries = 0
while True:
retries += 1
if retries > 10:
list2 = list1
position = random.choice(list2)
if not board._board[position[0]][position[1]]:
break
retries = 0
new_board = copy.deepcopy(board)
new_board.put([position[0], position[1]],
self.rec_cur_player[1])
self.rec_cur_player = [
self.rec_cur_player[1], self.rec_cur_player[0]]
node.left = BSTNode(new_board)
board = node.data
if not board or not board.is_free_cell():
return
if board.check_status() is not None:
return
while True:
retries += 1
if retries > 10:
list1 = list2
position = random.choice(list1)
if not board._board[position[0]][position[1]]:
break
new_board = copy.deepcopy(board)
new_board.put([position[0], position[1]],
self.COMPUTER_MARK)
node.right = BSTNode(new_board)
process(node.left)
process(node.right)
def recurse(items):
if not items:
return None
mid = len(items) // 2
return BSTNode(items[mid],
left=recurse(items[:mid]),
right=recurse(items[mid + 1:]))
def add(self, item):
"""Adds item to the tree."""
# Helper function to search for item's position
def recurse(node):
# New item is less, go left until spot is found
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
# New item is greater or equal,
# go right until spot is found
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
# End of recurse
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
recurse(self._root)
self._size += 1
def recursive(node, lst):
mid = len(lst) // 2
left = lst[:mid]
right = lst[mid + 1:]
# print('LEFT', left)
if left != []:
node.left = BSTNode(left[len(left) // 2])
recursive(node.left, left)
if right != []:
node.right = BSTNode(right[len(right) // 2])
recursive(node.right, right)
else:
return node
def rebalance(self):
'''
Rebalances the tree.
:return:
'''
lst = list(self.inorder())
self.clear()
def recursive(node, lst):
mid = len(lst) // 2
left = lst[:mid]
right = lst[mid + 1:]
# print('LEFT', left)
if left != []:
node.left = BSTNode(left[len(left) // 2])
recursive(node.left, left)
if right != []:
node.right = BSTNode(right[len(right) // 2])
recursive(node.right, right)
else:
return node
self._root = BSTNode(lst[len(lst) // 2])
recursive(self._root, lst)
def recurse(lyst):
if not lyst:
return None
mid = len(lyst) // 2
return BSTNode(lyst[mid], left=recurse(lyst[:mid]), right=recurse(lyst[mid+1:]))
def add(self, item):
"""Adds item to the tree."""
if (self._leftmost_node is not None
and item < self._leftmost_node.data):
self._leftmost_node.left = BSTNode(item)
self._leftmost_node = self._leftmost_node.left
return
if (self._rightmost_node is not None
and item > self._rightmost_node.data):
self._rightmost_node.right = BSTNode(item)
self._rightmost_node = self._rightmost_node.right
return
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
node = self._root
while True:
# New item is less, go left until spot is found
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
if (self._leftmost_node is None
or node.right.data < self._leftmost_node.data):
self._leftmost_node = node.left
break
else:
node = node.left
continue
# New item is greater or equal,
# go right until spot is found
elif node.right == None:
node.right = BSTNode(item)
if (self._rightmost_node is None
or node.right.data > self._rightmost_node.data):
self._rightmost_node = node.right
break
else:
node = node.right
self._size += 1
def custom_add(self, elements):
"""
Adds to the empty tree the list of elements.
:param elements: list
:rerurn: None
"""
self.clear()
self._root = BSTNode(elements[0])
elements.pop(0)
ptr = self._root
for element in elements:
if element.lower() < ptr.data.lower():
ptr.left = BSTNode(element)
ptr = ptr.left
else:
ptr.right = BSTNode(element)
ptr = ptr.right
self._size += 1
def recurse(node):
# New item is less; go left until spot is found
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
# New item is greater or equal;
# go right until spot is found
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
# Tree is empty, so new item goes at the root
if self.is_empty():
self.root = BSTNode(item)
else:
recurse(self.root)
self.size += 1
def add(self, item):
"""Adds item to the tree."""
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
parent = None
curr = self._root
while curr is not None:
parent = curr
if item < curr.data:
curr = curr.left
else:
curr = curr.right
if item < parent.data:
parent.left = BSTNode(item)
else:
parent.right = BSTNode(item)
self._size += 1
def add(self, item):
"""Adds item to the tree."""
# Tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
# Otherwise, search for the item's spot
else:
current = self._root
while True:
if item < current.data:
if current.left is not None:
current = current.left
else:
current.left = BSTNode(item)
break
else:
if current.right is not None:
current = current.right
else:
current.right = BSTNode(item)
break
self._size += 1
def add(self, item):
"""Adds item to the tree."""
curr_node = self._root
parent = None
if self._root is None:
self._root = BSTNode(item)
else:
while curr_node is not None:
parent = curr_node
if item < curr_node.data:
curr_node = curr_node.left
else:
curr_node = curr_node.right
if item < parent.data:
parent.left = BSTNode(item)
else:
parent.right = BSTNode(item)
self._size += 1
def add(self, item):
newNode = BSTNode(item)
def add_helper(node):
if self.root is None:
self.root = newNode
return
if item<node.data:
if node.left is None:
node.left = newNode
else:
add_helper(node.left)
else:
if node.right is None:
node.right = newNode
else:
add_helper(node.right)
add_helper(self.root)
self.size += 1
def add(self, item):
"""在二叉搜索树中插入一项"""
def recurse(node):
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
# If tree is empty, so new item goes at the root
if self.isEmpty():
self._root = BSTNode(item)
else:
recurse(self._root)
self._size += 1
def add(self, item):
"""增加item 到对应的位置"""
def recurse(node):
# item < node.data
if item < node.data:
if node.left == None:
node.left = BSTNode(item)
else:
recurse(node.left)
# item >= node.data
elif node.right == None:
node.right = BSTNode(item)
else:
recurse(node.right)
if self.isEmpty():
self._root = BSTNode(item)
else:
recurse(self._root)
self._size += 1
def predecessor(self, item):
"""
Returns the largest item that is smaller than
item, or None if there is no such item.
:param item:
:type item:
:return:
:rtype:
"""
pred = BSTNode(None)
node = self._root
while node:
if item > node.data:
pred = node
node = node.right
elif item < node.data:
node = node.left
else:
break
return pred.data
def remove(self, item):
"""Precondition: item is in self.
Raises: KeyError if item is not in self.
postcondition: item is removed from self."""
if not item in self:
raise KeyError("Item not in tree.""")
# Helper function to adjust placement of an item
def liftMaxInLeftSubtreeToTop(top):
# Replace top's datum with the maximum datum in the left subtree
# Pre: top has a left child
# Post: the maximum node in top's left subtree
# has been removed
# Post: top.data = maximum value in top's left subtree
parent = top
currentNode = top.left
while not currentNode.right == None:
parent = currentNode
currentNode = currentNode.right
top.data = currentNode.data
if parent == top:
top.left = currentNode.left
else:
parent.right = currentNode.left
# Begin main part of the method
if self.isEmpty(): return None
# Attempt to locate the node containing the item
itemRemoved = None
preRoot = BSTNode(None)
preRoot.left = self._root
parent = preRoot
direction = 'L'
currentNode = self._root
while not currentNode == None:
if currentNode.data == item:
itemRemoved = currentNode.data
break
parent = currentNode
if currentNode.data > item:
direction = 'L'
currentNode = currentNode.left
else:
direction = 'R'
currentNode = currentNode.right
# Return None if the item is absent
if itemRemoved == None: return None
# The item is present, so remove its node
# Case 1: The node has a left and a right child
# Replace the node's value with the maximum value in the
# left subtree
# Delete the maximium node in the left subtree
if not currentNode.left == None \
and not currentNode.right == None:
liftMaxInLeftSubtreeToTop(currentNode)
else:
# Case 2: The node has no left child
if currentNode.left == None:
newChild = currentNode.right
# Case 3: The node has no right child
else:
newChild = currentNode.left
# Case 2 & 3: Tie the parent to the new child
if direction == 'L':
parent.left = newChild
else:
parent.right = newChild
# All cases: Reset the root (if it hasn't changed no harm done)
# Decrement the collection's size counter
# Return the item
self._size -= 1
if self.isEmpty():
self._root = None
else:
self._root = preRoot.left
return itemRemoved