Example #1
0
class TestTraversalMethods(unittest.TestCase):
    # Separate class with a setUp tree designed for easy testing of intended
    #   traversal order.

    def setUp(self):
        self.tree = LinkedBinaryTree()
        self.root = self.tree._add_root(1)
        self.element2 = self.tree._add_left(self.root, 2)
        self.element3 = self.tree._add_right(self.root, 3)
        self.element4 = self.tree._add_left(self.element2, 4)
        self.element5 = self.tree._add_right(self.element2, 5)
        self.element6 = self.tree._add_left(self.element3, 6)
        self.element7 = self.tree._add_right(self.element3, 7)

    def test_preorder(self):
        visits_expected = [1, 2, 4, 5, 3, 6, 7]
        visits_actual = [] * 7  # List to store the visits in the order they happened
        for position in self.tree.preorder():
            visits_actual.append(position.element())
        self.assertEqual(visits_actual, visits_expected)

    def test_postorder(self):
        visits_expected = [4, 5, 2, 6, 7, 3, 1]
        visits_actual = [] * 7  # List to store the visits in order
        for position in self.tree.postorder():
            visits_actual.append(position.element())
        self.assertEqual(visits_actual, visits_expected)

    def test_breadthfirst(self):
        visits_expected = [1, 2, 3, 4, 5, 6, 7]
        visits_actual = [] * 7
        for position in self.tree.breadthfirst():
            visits_actual.append(position.element())
        self.assertEqual(visits_actual, visits_expected)
Example #2
0
def build_UNIST_tree():
    """
    This function returns a (linked) binary tree that contains (a simplified and fictitious  version of)
    the organisational structure of schools and departments at UNIST.
    In particular, this function should return the following tree:
    
    UNIST
    --Engineering
    ----Management Engineering
    ------Big datastore
    ------Business process management
    ----Materials Engineering
    ------Wood
    ------Plastic
    --Business
    ----Business Administration

    """
    tree = LinkedBinaryTree()
    root = tree._add_root("UNIST")
    p_eng = tree._add_left(root, "Engineering")
    p_business = tree._add_right(root, "Business")
    p_man_eng = tree._add_left(p_eng, "Management Engineering")
    p_big_data = tree._add_left(p_man_eng, "Big datastore")
    p_bpm = tree._add_right(p_man_eng, "Business process management")
    p_mat_eng = tree._add_right(p_eng, "Materials Engineering")
    p_ba = tree._add_left(p_business, "Business Administration")
    return tree
Example #3
0
def main():
    gs = GS()
    print("To terminate game, type -1 -1")
    usrstep = gs.getUserStep()

    while usrstep[0] != -1:

        gs.make_step(gs.board(), usrstep[0], usrstep[1], Board.CROSS_CELL)

        if gs.board().check_for_win_combos(Board.CROSS_CELL):
            print(gs.board())
            print("CONGRATULATIONS! YOU WON!")
            break
        elif gs.board().is_full():
            print("TIGHT!")

        # generate two possible steps
        option1 = gs.generate_step(gs.board())
        option2 = gs.generate_step(gs.board())

        cross = gs.board().get_cross_cells()
        zeros = gs.board().get_zero_cells()

        # build two new boards
        board1 = Board(3, 3)
        board1.configure(cross.append(option1))
        board1.configure(zeros)

        board2 = Board(3, 3)
        board2.configure(cross[:-1].append(option2))
        board2.configure(zeros)

        # build two new decision binary trees
        tree1 = LinkedBinaryTree(board1)
        tree2 = LinkedBinaryTree(board2)

        # calculate the number of victories for each tree
        gs.fill_board(tree1, tree1)
        result1 = gs.get_numVictories()

        gs.clear_victories()

        gs.fill_board(tree2, tree2)
        result2 = gs.get_numVictories()

        # choose the step with the biggest number of victories
        if result1 > result2:
            gs.make_step(gs.board(), option1[0], option1[1], Board.ZERO_CELL)
        else:
            gs.make_step(gs.board(), option2[0], option2[1], Board.ZERO_CELL)

        print(gs.board())
        if gs.board().check_for_win_combos():
            print("YOU LOST!")
            break
        elif gs.board().check_for_win_combos(Board.CROSS_CELL):
            print("CONGRATULATIONS! YOU WON!")
            break
        print("To terminate game, type -1 -1")
        usrstep = gs.getUserStep()
Example #4
0
 def setUp(self):
     self.tree = LinkedBinaryTree()
     self.root = self.tree._add_root(1)
     self.element2 = self.tree._add_left(self.root, 2)
     self.element3 = self.tree._add_right(self.root, 3)
     self.element4 = self.tree._add_left(self.element2, 4)
     self.element5 = self.tree._add_right(self.element2, 5)
     self.element6 = self.tree._add_left(self.element3, 6)
     self.element7 = self.tree._add_right(self.element3, 7)
Example #5
0
 def setUp(self):
     self.tree = LinkedBinaryTree()
     # Create a proper balanced tree with 3 levels (8 elements)
     self.root = self.tree._add_root("Root")
     self.left = self.tree._add_left(self.root, "L2 left child")
     self.right = self.tree._add_right(self.root, "L2 right child")
     self.lev3_first_left = self.tree._add_left(self.left, "L3 left-1")
     self.tree._add_right(self.left, "L3 right-1")
     self.tree._add_left(self.right, "L3 left-2")
     self.tree._add_right(self.right, "L3 right-2")
Example #6
0
def make_tree(previous):
    """Сonstructing a game tree, by extending 
    (by adding two child vertices) from the root of a tree """
    # previous it is Board()
    if previous.if_won() == -1 or previous.if_won() == 1:
        return None
    
    new_move_left = random.choice(previous.empty_list())
    tree = LinkedBinaryTree(previous)

    if len(previous.empty_list()) == 0:
        return None
    new_previous = copy.deepcopy(previous)
    new_previous.set_null(new_move_left)

    tree.left_child = LinkedBinaryTree(new_previous)
    make_tree(new_previous)
    
    if len(new_previous.empty_list()) == 0:
        return None
    new_move_right = random.choice(new_previous.empty_list())
    n_new_previous = copy.deepcopy(new_previous)
    n_new_previous.set_null(new_move_right)

    tree.right_child = LinkedBinaryTree(n_new_previous)
    make_tree(n_new_previous)
Example #7
0
    def build_tree(self):
        """
        Builds the game tree
        :return: object
        """
        game_tree = LinkedBinaryTree()
        board = self.board
        game_tree._add_root(Board(board))

        def add_board(tree, node):
            """
            adds new board to a tree
            :param tree: object
            :param node: object
            :return: None
            """
            positions = self.available_positions(node._element)
            if not positions:
                return None
            if tree.height() == tree.depth(tree._make_position(node)) \
                    and tree.height() % 2 == 0:
                symbol = 'o'
            else:
                symbol = 'x'
            pos = random.choice(positions)
            new_board = Board(node._element.board)
            new_board.board[pos[0], pos[1]] = symbol
            tree._add_left(tree._make_position(node), Board(new_board.board))
            positions = self.available_positions(new_board)
            if not positions:
                return None
            pos = random.choice(positions)
            new_board = Board(node._element.board)
            new_board.board[pos[0], pos[1]] = symbol
            tree._add_right(tree._make_position(node), Board(new_board.board))
            add_board(tree, node._left)
            add_board(tree, node._right)

        add_board(game_tree, game_tree._root)
        return game_tree
Example #8
0
 def test_validate(self):
     # Passing an object of type other than Position should raise TypeError
     with self.assertRaises(TypeError):
         self.tree._validate("spam")
     # Wrong container should raise value error
     position_from_other_container = LinkedBinaryTree()._add_root(
         "spam root")
     with self.assertRaises(ValueError):
         self.tree._validate(position_from_other_container)
     # If node was deprecated, meaning it was set to be its own parent per
     #   the internal convention for deprecated nodes, then should raise
     #   value error.
     p = self.lev3_first_left
     p._node._parent = p._node
     with self.assertRaises(ValueError):
         self.tree._validate(p)
Example #9
0
def play_game():
    load = is_yes(input("Load game? "))
    if not load:
        guess = Guesser("Does it have legs?", "cat", "snake")
        print()
    else:
        guess = LinkedBinaryTree.load_tree("tree.dat")
        print("Loaded\n")
    again = True
    while again:
        print("Think of an animal, and I will guess it.")
        again = ask(guess)
        if again:
            print()
    if is_yes(input("Save game? ")):
        guess.save_tree("tree.dat")
        print("Saved")
Example #10
0
def build_tree(b):
    if b.someone_wins == "TIE" or b.someone_wins == "O" or b.someone_wins == "X":
        return

    tree = LinkedBinaryTree(b)
    free_cells = b.empty_coords
    random_cell1 = choice(list(free_cells))
    choice1 = deepcopy(b)
    choice1.turn("O", random_cell1)
    tree.left_child = LinkedBinaryTree(choice1)
    build_tree(choice1)

    free_cells.discard(random_cell1)
    if free_cells != set():  # we have to check if set isn't empty
        random_cell2 = choice(list(free_cells))
        choice2 = deepcopy(b)
        choice2.turn("O", random_cell2)
        tree.right_child = LinkedBinaryTree(choice2)
        build_tree(choice2)
Example #11
0
def construct_tree():
    t = LinkedBinaryTree()
    root = t._add_root('Trees')
    l = t._add_left(root, 'General trees')
    r = t._add_right(root, 'Binary trees')

    t1 = LinkedBinaryTree()
    root = t1._add_root('section1')
    left = t1._add_left(root, 'paragraph1')
    right = t1._add_right(root, 'paragraph2')

    t2 = LinkedBinaryTree()
    root = t2._add_root('section2')
    left = t2._add_left(root, 'paragraph1')
    right = t2._add_right(root, 'paragraph2')

    t._attach(l, t1, t2)
    return t
Example #12
0
    def _compose_ht_tree(self, text):
        """Huffman tree construction for text."""
        freq_table = self._compute_chr_freq(text)
        ht_queue = HeapPriorityQueue()
        for freq, lett in freq_table:
            ht_tree = LinkedBinaryTree()
            ht_tree._add_root((freq, lett))
            ht_queue.add(freq, ht_tree)

        while len(ht_queue) > 1:
            (freq1, subtree1) = ht_queue.remove_min()
            (freq2, subtree2) = ht_queue.remove_min()
            freq = freq1 + freq2
            ht_tree = LinkedBinaryTree()
            ht_tree._add_root((freq, None))
            ht_tree._attach(ht_tree.root(), subtree1, subtree2)
            ht_queue.add(freq, ht_tree)
        _, ht_tree = ht_queue.remove_min()
        return ht_tree
Example #13
0
def build_UNIST_tree():
    """
    This function should return a binary tree that contains (a simplified and fictitious  version of) the organisational
    structure of schools and departments at UNIST. In particular, this function should return the following tree:
`+-*
    UNIST
    --Engineering
    ----Management Engineering
    ------Big data
    ------Business process management
    ----Materials Engineering
    ------Wood
    ------Plastic
    --Business
    ----Business Administration

    :return: the UNIST tree
    """
    UNIST = LinkedBinaryTree()
    root = UNIST._add_root("UNIST")
    EE = UNIST._add_left(root, "Engineering")
    BU = UNIST._add_right(root, "Bussiness")

    MNE = UNIST._add_left(EE, "Management Engineering")
    UNIST._add_left(MNE, "Big data")
    UNIST._add_right(MNE, "Business process management")
    MTE = UNIST._add_right(EE, "Material Engineering")
    UNIST._add_left(MTE, "Wood")
    UNIST._add_right(MTE, "Plastic")

    UNIST._add_left(BU, "Business Administration")

    return UNIST
def create_tree():
    t = LinkedBinaryTree()
    f = t._add_root('f')

    # left tree
    b = t._add_left(f, 'b')
    t._add_left(b, 'a')
    d = t._add_right(b, 'd')
    t._add_left(d, 'c')
    t._add_right(d, 'e')

    # right tree
    g = t._add_right(f, 'g')
    i = t._add_right(g, 'i')
    t._add_left(i, 'h')
    return t
Example #15
0
from linked_binary_tree import LinkedBinaryTree

test_tr = LinkedBinaryTree(' a')
#test_tr.is_empty()
print(test_tr)
print("root_val ", test_tr.get_root_val())
print("left_child ", test_tr.get_left_child())
test_tr.insert_left(' b')
print("left_child ", test_tr.get_left_child())
print("left_child().get_root_val ", test_tr.get_left_child().get_root_val())

test_tr.insert_left(' bb')
print("left_child ", test_tr.get_left_child())
print("left_child().get_root_val ", test_tr.get_left_child().get_root_val())

test_tr.insert_right(' c')
print("right_child ", test_tr.get_right_child())
print("right_child().get_root_val ", test_tr.get_right_child().get_root_val())
test_tr.get_right_child().set_root_val(' hello')
print("right_child().get_root_val", test_tr.get_right_child().get_root_val())

test_tr.inorder()

a_node = LinkedBinaryTree('A')
a_node.insert_left('B')
a_node.insert_right('C')

b_node = a_node.left_child
b_node.insert_right('D')

c_node = a_node.right_child
Example #16
0
"""Preorder traversal"""

# 应该使用普通的树而不是二叉树
from linked_binary_tree import LinkedBinaryTree

# Electronics R’Us
#   1 R&D
#   2 Sales
#     2.1 Domestic
#     2.2 International
#       2.2.1 Canada
#       2.2.2 America
toc = LinkedBinaryTree()
toc._add_root('Electronics R’Us')
toc._add_left(toc.root(), 'R&D')
toc._add_right(toc.root(), 'Sales')
toc._add_left(toc.right(toc.root()), 'Domestic')
toc._add_right(toc.right(toc.root()), 'International')
toc._add_left(toc.right(toc.right(toc.root())), 'Canada')
toc._add_right(toc.right(toc.right(toc.root())), 'America')


def parenthesize(t, p, rep):
    if t.is_empty():
        return

    rep += str(p.element())

    if not t.is_leaf(p):
        first_time = True
        for c in t.children(p):
Example #17
0
"""Preorder traversal"""

# 应该使用普通的树而不是二叉树
from linked_binary_tree import LinkedBinaryTree

# Electronics R’Us
#   1 R&D
#   2 Sales
#     2.1 Domestic
#     2.2 International
#       2.2.1 Canada
#       2.2.2 America
toc = LinkedBinaryTree()
toc._add_root('Electronics R’Us')
toc._add_left(toc.root(), 'R&D')
toc._add_right(toc.root(), 'Sales')
toc._add_left(toc.right(toc.root()), 'Domestic')
toc._add_right(toc.right(toc.root()), 'International')
toc._add_left(toc.right(toc.right(toc.root())), 'Canada')
toc._add_right(toc.right(toc.right(toc.root())), 'America')

# Solution 1: O(n^2)
# for p in toc.preorder():
#     print(toc.depth(p)*2*' '+p.element())


# Solution 2: O(n)
def preorder_indent(t, p, d):
    print(2 * d * ' ' + p.element())
    for c in t.children(p):
        preorder_indent(t, c, d + 1)
Example #18
0
 def test_root(self):
     blank_tree = LinkedBinaryTree()
     root = blank_tree.root()
     self.assertEqual(root, None)  # Should return None for an empty tree.
     root = self.tree.root()
     self.assertEqual(root.element(), "Root")
Example #19
0
from linked_binary_tree import LinkedBinaryTree

a = LinkedBinaryTree()
print('!!!')
a._add_root('!!')
a._add_left(a.root(), '????')
print('!')
print(a.left(a.root()).element())
a._delete(a.left(a.root()))
Example #20
0
def construct_num_tree():
    t = LinkedBinaryTree()
    root = t._add_root(0)
    l = t._add_left(root, 1)
    r = t._add_right(root, 2)

    t1 = LinkedBinaryTree()
    root = t1._add_root(3)
    left = t1._add_left(root, 5)
    right = t1._add_right(root, 6)

    t2 = LinkedBinaryTree()
    root = t2._add_root(4)
    left = t2._add_left(root, 7)
    right = t2._add_right(root, 8)

    t._attach(l, t1, t2)
    return t
Example #21
0
 def __init__(self):
     self.cells = [[0] * 3 for _ in range(3)]
     self.last_move = Board.NOUGHT
     self.number_of_moves = 0
     self.status = None
     self.tree = LinkedBinaryTree(self)
Example #22
0
class TestSimpleCases(unittest.TestCase):
    """
    Test obvious cases to confirm basic functionality and syntax
    correctness.
    """
    def setUp(self):
        self.tree = LinkedBinaryTree()
        # Create a proper balanced tree with 3 levels (8 elements)
        self.root = self.tree._add_root("Root")
        self.left = self.tree._add_left(self.root, "L2 left child")
        self.right = self.tree._add_right(self.root, "L2 right child")
        self.lev3_first_left = self.tree._add_left(self.left, "L3 left-1")
        self.tree._add_right(self.left, "L3 right-1")
        self.tree._add_left(self.right, "L3 left-2")
        self.tree._add_right(self.right, "L3 right-2")

    def test_validate(self):
        # Passing an object of type other than Position should raise TypeError
        with self.assertRaises(TypeError):
            self.tree._validate("spam")
        # Wrong container should raise value error
        position_from_other_container = LinkedBinaryTree()._add_root(
            "spam root")
        with self.assertRaises(ValueError):
            self.tree._validate(position_from_other_container)
        # If node was deprecated, meaning it was set to be its own parent per
        #   the internal convention for deprecated nodes, then should raise
        #   value error.
        p = self.lev3_first_left
        p._node._parent = p._node
        with self.assertRaises(ValueError):
            self.tree._validate(p)

    # ---------------------------------- public methods --------------------

    def test_root(self):
        blank_tree = LinkedBinaryTree()
        root = blank_tree.root()
        self.assertEqual(root, None)  # Should return None for an empty tree.
        root = self.tree.root()
        self.assertEqual(root.element(), "Root")

    def test_parent(self):
        # should return None when called on p = root
        parent_of_root = self.tree.parent(self.tree.root())
        self.assertEqual(parent_of_root, None)
        parent_of_left = self.tree.parent(self.left)  # Position object from
        # setUp, name self.left references
        # root's left child.
        self.assertEqual(parent_of_left, self.root)
        # Try the next level down
        parent_of_node = self.tree.parent(self.lev3_first_left)
        self.assertEqual(parent_of_node, self.left)

    def test_left(self):
        left = self.tree.left(self.root)  # parent's left should be the object
        #   stored as self.left
        self.assertEqual(left, self.left)

    def test_right(self):
        right = self.tree.right(self.root)  # root's right should be the object
        # stored as self.right
        self.assertEqual(right, self.right)

    def test_num_children(self):
        self.assertEqual(self.tree.num_children(self.root),
                         2)  # Root has 2 children
        self.assertEqual(self.tree.num_children(self.right), 2)  # Right has 2
        self.assertEqual(self.tree.num_children(self.lev3_first_left),
                         0)  # This node should be in the
        # bottom level of the setUp
        # tree and therefore have
        # no children.

    # ------------------- tests for concrete methods inherited from Tree ------

    def test_is_root(self):
        """Concrete method implemented in the Tree abstract base class and
        inherited through to LBT class."""
        # Should be true for root
        self.assertTrue(self.tree.is_root(self.root))
        # Should be false for a node from the middle or bottom layer
        self.assertFalse(self.tree.is_root(self.right))
        self.assertFalse(self.tree.is_root(self.lev3_first_left))

    def test_is_leaf(self):
        # testing _attach will "coverage" this
        pass

    def test_is_empty(self):
        # testing _attach will "coverage this
        pass

    def test_height(self):
        """
        Test the height method defined in the Tree abstract base class
        that LBT class has through inheritance.
        """
        # Calling it on root should return 2, the height of the full three-level
        #   tree.
        self.assertEqual(self.tree.height(self.root), 2)
        # Height of a node in the middle layer should be 1
        self.assertEqual(self.tree.height(self.right), 1)
        # Height of a node in the bottom layer should be 0
        self.assertEqual(self.tree.height(self.lev3_first_left), 0)

    def test_depth(self):
        """
        Test the depth method defined in the Tree abstract base class and
        inherited in the LBT class.
        """
        # Depth of a node in the bottom later should be 2 (2 levels separating
        #   that Position from root Position).
        self.assertEqual(self.tree.depth(self.lev3_first_left), 2)
        # Depth of node in middle layer should be 1
        self.assertEqual(self.tree.depth(self.left), 1)
        # Depth of root should be zero
        self.assertEqual(self.tree.depth(self.root), 0)

    def test_attach(self):
        """Tests for the nonpublic _attach method, mainly to hit inherited public
        methods that it will call."""
        new_tree = LinkedBinaryTree()
        ntroot = new_tree._add_root("New tree root")
        new_tree._add_left(ntroot, "NT left")
        new_tree._add_right(ntroot, "NT right")
        new_tree2 = LinkedBinaryTree()
        nt2root = new_tree2._add_root("2nd new tree root")
        new_tree2._add_left(nt2root, "left")
        new_tree2._add_right(nt2root, "right")
        self.tree._attach(self.lev3_first_left, new_tree, new_tree2)
        # For now just pass if none of these calls raised an error, no
        #   unittest.assertSomething method call

    def test_positions(self):  # This covers postorder() method for purposes
        # of the "coverage" metric.
        for position in self.tree.positions(
        ):  # Test that they can be iterated
            self.assertIsInstance(position,
                                  LinkedBinaryTree.Position)  # and that
            # they're all Positions


##    def test_preorder(self): # placeholder
##        pass

    def test_postorder(self):
        for position in self.tree.postorder():
            self.assertIsInstance(position, LinkedBinaryTree.Position)
    if T.left(p) is not None:
        inorder(T.left(p))
    print T._validate(p)._element
    if T.right(p) is not None:
        inorder(T.right(p))    

if __name__ == '__main__':
    import random
    
    def build_tree(T, p, level):
        if level > 5:
            return None
        else:
            if T.left(p) is None:
                T._add_left(p, random.randint(1, 10))
                build_tree(T, T.left(p), level+1)
            if T.right(p) is None:
                T._add_right(p, random.randint(1, 10))
                build_tree(T, T.right(p), level+1)            
    
    test_tree = LinkedBinaryTree()
    test_tree._add_root('10')
    build_tree(test_tree, test_tree.root(), 1)
    
    count = 1
    for x in test_tree.positions():
        print str(count) +': ' + str(test_tree._validate(x)._element)
        count += 1


Example #24
0
 def test_attach(self):
     """Tests for the nonpublic _attach method, mainly to hit inherited public
     methods that it will call."""
     new_tree = LinkedBinaryTree()
     ntroot = new_tree._add_root("New tree root")
     new_tree._add_left(ntroot, "NT left")
     new_tree._add_right(ntroot, "NT right")
     new_tree2 = LinkedBinaryTree()
     nt2root = new_tree2._add_root("2nd new tree root")
     new_tree2._add_left(nt2root, "left")
     new_tree2._add_right(nt2root, "right")
     self.tree._attach(self.lev3_first_left, new_tree, new_tree2)
Example #25
0
from linked_binary_tree import LinkedBinaryTree

test_tr = LinkedBinaryTree(' a')
print(test_tr)
print("root_val ", test_tr.get_root_val())
print("left_child ", test_tr.get_left_child())
test_tr.insert_left(' b')
print("left_child ", test_tr.get_left_child())
print("left_child().get_root_val ", test_tr.get_left_child().get_root_val())
test_tr.insert_right(' c')
print("right_child ", test_tr.get_right_child())
print("right_child().get_root_val ", test_tr.get_right_child().get_root_val())
r.get_right_child().set_root_val(' hello')
print("right_child().get_root_val", test_tr.get_right_child().get_root_val())

print(test_tr)
Example #26
0
from linked_binary_tree import LinkedBinaryTree

# Construct Tree:

T = LinkedBinaryTree()
T.add_root(1)
p1 = T.add_left(T.root(), 2)
p2 = T.add_right(T.root(), 3)

T.add_left(p1, 4)
T.add_right(p1, 5)

p3 = T.add_left(p2, 6)
p4 = T.add_right(p2, 7)

T.add_left(p3, 8)
T.add_right(p3, 9)

T.add_right(p4, 10)

# Check Traversals:

print("\nPreorder: ")
for p in T.preorder():
    print(p.element())

print("\nPostorder: ")
for p in T.postorder():
    print(p.element())

print("\nInorder: ")