예제 #1
0
def doubleTree(root):
    if (root is None): return
    node = Node(root.value)
    node.insert(root.value)
    node.left.left = doubleTree(root.left)
    node.right = doubleTree(root.right)
    return node
예제 #2
0
    def test_insert_right_child(self):
        node = Node(3, 'value')
        node.insert(4, 'right_value')

        assert node.right_child.right_child is None
        node.insert(5, 'right_child_value')
        assert node.right_child.right_child is not None
        assert node.right_child.right_child.key == 5
        assert node.right_child.right_child.value == 'right_child_value'
예제 #3
0
    def test_insert_left_child(self):
        node = Node(3, 'value')
        node.insert(2, 'left_value')

        assert node.left_child.left_child is None
        node.insert(1, 'left_child_value')
        assert node.left_child.left_child is not None
        assert node.left_child.left_child.key == 1
        assert node.left_child.left_child.value == 'left_child_value'
예제 #4
0
    def test_insert_right_child(self):
        node = Node(3, 'value')
        node.insert(4, 'right_value')

        assert node.right_child.right_child is None
        node.insert(5, 'right_child_value')
        assert node.right_child.right_child is not None
        assert node.right_child.right_child.key == 5
        assert node.right_child.right_child.value == 'right_child_value'
예제 #5
0
    def test_insert_left_child(self):
        node = Node(3, 'value')
        node.insert(2, 'left_value')

        assert node.left_child.left_child is None
        node.insert(1, 'left_child_value')
        assert node.left_child.left_child is not None
        assert node.left_child.left_child.key == 1
        assert node.left_child.left_child.value == 'left_child_value'
예제 #6
0
    def test_insert_no_right_child(self):
        node = Node(3, 'value')

        assert node.right_child is None
        assert node.insert(4, 'right_value') is True
        assert node.right_child is not None
        assert node.right_child.key == 4
        assert node.right_child.value == 'right_value'
예제 #7
0
    def test_insert_no_left_child(self):
        node = Node(3, 'value')

        assert node.left_child is None
        assert node.insert(2, 'left_value') is True
        assert node.left_child is not None
        assert node.left_child.key == 2
        assert node.left_child.value == 'left_value'
예제 #8
0
    def test_insert_no_right_child(self):
        node = Node(3, 'value')

        assert node.right_child is None
        assert node.insert(4, 'right_value') is True
        assert node.right_child is not None
        assert node.right_child.key == 4
        assert node.right_child.value == 'right_value'
예제 #9
0
    def test_insert_no_left_child(self):
        node = Node(3, 'value')

        assert node.left_child is None
        assert node.insert(2, 'left_value') is True
        assert node.left_child is not None
        assert node.left_child.key == 2
        assert node.left_child.value == 'left_value'
예제 #10
0
    def test_get_node_list(self):
        node = Node(4, 'a')
        node.insert(2, 'b')
        node.insert(5, 'c')
        node.insert(1, 'd')
        node.insert(3, 'e')
        node.insert(6, 'f')

        assert node.get_node_list(node) == [1, 2, 3, 4, 5, 6]
예제 #11
0
    def test_get_node_list(self):
        node = Node(4, 'a')
        node.insert(2, 'b')
        node.insert(5, 'c')
        node.insert(1, 'd')
        node.insert(3, 'e')
        node.insert(6, 'f')

        assert node.get_node_list(node) == [1, 2, 3, 4, 5, 6]
예제 #12
0
    def test_insert_same_key(self):
        node = Node(3, 'value')

        assert node.insert(3, 'value') is False
예제 #13
0
def build123():
    root = Node(2)
    root.insert(1)
    root.insert(3)
    return root
예제 #14
0
#!/usr/bin/python
from binarytree import Node
import sys

TREE_1 = Node(4)
TREE_1.insert(2)
TREE_1.insert(5)
TREE_1.insert(1)
TREE_1.insert(3)


def build123():
    root = Node(2)
    root.insert(1)
    root.insert(3)
    return root


def size(root):
    if (root is None):
        return 0
    return 1 + size(root.left) + size(root.right)


def maxDepth(root):
    if (root is None):
        return 0
    return 1 + max(maxDepth(root.left), maxDepth(root.right))


def minValue(root):
예제 #15
0
def pre_process_points(points):
    global stop_y
    global sls
    global intersection_discovered
    global intersection_point

    for i in xrange(len(points)):
        print "Coordinates = " + str(points[i].x) + "," + str(points[i].y)

    # Sort the points in the event queue by y-coordinate
    event_queue = sorted(points, key=lambda point: point.y)
    last_point = 0
    sls = None
    index = 0
    # Consider each point in the event queue
    for current_point in event_queue:
        stop_y = current_point.y - last_point
        # If the current point has a previous point, insert that line segment into the sls
        if current_point.prev_point is not None:
            line_segment_1 = LineSegment(current_point,
                                         current_point.prev_point,
                                         current_point.prev_point.index)
            line_segment_1_dup = LineSegment(current_point.prev_point,
                                             current_point,
                                             current_point.prev_point.index)
            if sls is None:
                sls = Node(line_segment_1)
                index = index + 1
            else:
                # Verify that line segment is not already present
                lsegment = sls.lookup(line_segment_1)
                rsegment = sls.lookup(line_segment_1_dup)
                if lsegment[0] is None and rsegment[0] is None:
                    sls.insert(line_segment_1)
                    index = index + 1
                    findPreSuc.pre = None
                    findPreSuc.suc = None
                    findPreSuc(sls, line_segment_1)

                    # Check for intersection with predecessor
                    if findPreSuc.pre is not None and abs(
                            findPreSuc.pre.data.index -
                            line_segment_1.index) > 1:
                        if do_intersect(findPreSuc.pre.data.start,
                                        findPreSuc.pre.data.end,
                                        line_segment_1.start,
                                        line_segment_1.end):
                            print "Predecessor is", findPreSuc.pre.data.label, "{(", \
                                findPreSuc.pre.data.start.x, ",", findPreSuc.pre.data.start.y, "),(", \
                                findPreSuc.pre.data.end.x, ",", findPreSuc.pre.data.end.y, ")}"
                            print "Current Point is", line_segment_1.label, "{(", \
                                line_segment_1.start.x, ",", line_segment_1.start.y, "),(", \
                                line_segment_1.end.x, ",", line_segment_1.end.y, ")}"
                            print "Intersection Discovered1"
                            intersection_discovered = True
                            intersection_point = get_intersection_point(
                                findPreSuc.pre.data, line_segment_1)
                            if automate_clicked:
                                if test is not None:
                                    sls_canvas.delete(test)
                                test = sls_canvas.create_text(
                                    window_width / 2,
                                    20,
                                    fill="darkblue",
                                    font="Times 20 italic bold",
                                    text="Intersection Discovered at (" +
                                    str(intersection_point.x) + ", " +
                                    str(intersection_point.y) + ")",
                                    anchor=CENTER)
                                child_canvas.create_oval(
                                    intersection_point.x - 2.0,
                                    intersection_point.y - 2.0,
                                    intersection_point.x + 2.0,
                                    intersection_point.y + 2.0,
                                    outline="red",
                                    fill="red",
                                    width=2)

                    # Check for intersection with successor
                    if findPreSuc.suc is not None and abs(
                            findPreSuc.suc.data.index -
                            line_segment_1.index) > 1:
                        if do_intersect(findPreSuc.suc.data.start,
                                        findPreSuc.suc.data.end,
                                        line_segment_1.start,
                                        line_segment_1.end):
                            print "Successor is", findPreSuc.suc.data.label, "{(", \
                                findPreSuc.suc.data.start.x, ",", findPreSuc.suc.data.start.y, "),(", \
                                findPreSuc.suc.data.end.x, ",", findPreSuc.suc.data.end.y, ")}"
                            print "Current Point is", line_segment_1.label, "{(", \
                                line_segment_1.start.x, ",", line_segment_1.start.y, "),(", \
                                line_segment_1.end.x, ",", line_segment_1.end.y, ")}"
                            print "Intersection Discovered2"
                            intersection_discovered = True
                            intersection_point = get_intersection_point(
                                findPreSuc.suc.data, line_segment_1)
                            if automate_clicked:
                                if test is not None:
                                    sls_canvas.delete(test)
                                test = sls_canvas.create_text(
                                    window_width / 2,
                                    20,
                                    fill="darkblue",
                                    font="Times 20 italic bold",
                                    text="Intersection Discovered at (" +
                                    str(intersection_point.x) + ", " +
                                    str(intersection_point.y) + ")",
                                    anchor=CENTER)
                                child_canvas.create_oval(
                                    intersection_point.x - 2.0,
                                    intersection_point.y - 2.0,
                                    intersection_point.x + 2.0,
                                    intersection_point.y + 2.0,
                                    outline="red",
                                    fill="red",
                                    width=2)
                else:
                    # If the line segment already exists in the sls, delete it
                    if lsegment[0] is not None:
                        findPreSuc.pre = None
                        findPreSuc.suc = None
                        findPreSuc(sls, lsegment[0].data)
                        sls.delete(lsegment[0].data)
                    else:
                        findPreSuc.pre = None
                        findPreSuc.suc = None
                        findPreSuc(sls, rsegment[0].data)
                        sls.delete(rsegment[0].data)

                    # Check for intersection with new successor and predecessor
                    if findPreSuc.pre is not None and findPreSuc.suc is not None and \
                            abs(findPreSuc.pre.data.index - findPreSuc.suc.data.index) > 1 and\
                            do_intersect(findPreSuc.pre.data.start, findPreSuc.pre.data.end,
                                    findPreSuc.suc.data.start,
                                    findPreSuc.suc.data.end):
                        print "Predecessor is", findPreSuc.pre.data.label, "{(", \
                            findPreSuc.pre.data.start.x, ",", findPreSuc.pre.data.start.y, "),(", \
                            findPreSuc.pre.data.end.x, ",", findPreSuc.pre.data.end.y, ")}"
                        print "Successor is", findPreSuc.suc.data.label, "{(", \
                            findPreSuc.suc.data.start.x, ",", findPreSuc.suc.data.start.y, "),(", \
                            findPreSuc.suc.data.end.x, ",", findPreSuc.suc.data.end.y, ")}"
                        print "Intersection Discovered3"
                        intersection_discovered = True
                        intersection_point = get_intersection_point(
                            findPreSuc.pre.data, findPreSuc.suc.data)
                        if automate_clicked:
                            if test is not None:
                                sls_canvas.delete(test)
                            test = sls_canvas.create_text(
                                window_width / 2,
                                20,
                                fill="darkblue",
                                font="Times 20 italic bold",
                                text="Intersection Discovered at (" +
                                str(intersection_point.x) + ", " +
                                str(intersection_point.y) + ")",
                                anchor=CENTER)
                            child_canvas.create_oval(
                                intersection_point.x - 2.0,
                                intersection_point.y - 2.0,
                                intersection_point.x + 2.0,
                                intersection_point.y + 2.0,
                                outline="red",
                                fill="red",
                                width=2)
                        return

        # If the current point has a next point, insert that line segment into the sls
        if current_point.next_point is not None:
            line_segment_2 = LineSegment(current_point,
                                         current_point.next_point,
                                         current_point.index)
            line_segment_2_dup = LineSegment(current_point.next_point,
                                             current_point,
                                             current_point.index)
            if sls is None:
                sls = Node(line_segment_2)
                index = index + 1
            else:
                lsegment = sls.lookup(line_segment_2)
                rsegment = sls.lookup(line_segment_2_dup)
                # Verify that line segment is not already present
                if lsegment[0] is None and rsegment[0] is None:
                    sls.insert(line_segment_2)
                    index = index + 1
                    findPreSuc.pre = None
                    findPreSuc.suc = None
                    findPreSuc(sls, line_segment_2)
                    # Check for intersection with predecessor
                    if findPreSuc.pre is not None and abs(
                            findPreSuc.pre.data.index -
                            line_segment_2.index) > 1:
                        if do_intersect(findPreSuc.pre.data.start,
                                        findPreSuc.pre.data.end,
                                        line_segment_2.start,
                                        line_segment_2.end):
                            print "Predecessor is", findPreSuc.pre.data.label, "{(", \
                                findPreSuc.pre.data.start.x, ",", findPreSuc.pre.data.start.y, "),(", \
                                findPreSuc.pre.data.end.x, ",", findPreSuc.pre.data.end.y, ")}"
                            print "Current Point is", line_segment_2.label, "{(", \
                                line_segment_2.start.x, ",", line_segment_2.start.y, "),(", \
                                line_segment_2.end.x, ",", line_segment_2.end.y, ")}"
                            print "Intersection Discovered4"
                            intersection_discovered = True
                            intersection_point = get_intersection_point(
                                findPreSuc.pre.data, line_segment_2)
                            if automate_clicked:
                                if test is not None:
                                    sls_canvas.delete(test)
                                test = sls_canvas.create_text(
                                    window_width / 2,
                                    20,
                                    fill="darkblue",
                                    font="Times 20 italic bold",
                                    text="Intersection Discovered at (" +
                                    str(intersection_point.x) + ", " +
                                    str(intersection_point.y) + ")",
                                    anchor=CENTER)
                                child_canvas.create_oval(
                                    intersection_point.x - 2.0,
                                    intersection_point.y - 2.0,
                                    intersection_point.x + 2.0,
                                    intersection_point.y + 2.0,
                                    outline="red",
                                    fill="red",
                                    width=2)
                            return

                    # Check for intersection with successor
                    if findPreSuc.suc is not None and abs(
                            findPreSuc.suc.data.index -
                            line_segment_2.index) > 1:
                        if do_intersect(findPreSuc.suc.data.start,
                                        findPreSuc.suc.data.end,
                                        line_segment_2.start,
                                        line_segment_2.end):
                            print "Successor is", findPreSuc.suc.data.label, "{(", \
                                findPreSuc.suc.data.start.x, ",", findPreSuc.suc.data.start.y, "),(", \
                                findPreSuc.suc.data.end.x, ",", findPreSuc.suc.data.end.y, ")}"
                            print "Current Point is", line_segment_2.label, "{(", \
                                line_segment_2.start.x, ",", line_segment_2.start.y, "),(", \
                                line_segment_2.end.x, ",", line_segment_2.end.y, ")}"
                            print "Intersection Discovered5"
                            intersection_discovered = True
                            intersection_point = get_intersection_point(
                                findPreSuc.suc.data, line_segment_2)
                            if automate_clicked:
                                if test is not None:
                                    sls_canvas.delete(test)
                                test = sls_canvas.create_text(
                                    window_width / 2,
                                    20,
                                    fill="darkblue",
                                    font="Times 20 italic bold",
                                    text="Intersection Discovered at (" +
                                    str(intersection_point.x) + ", " +
                                    str(intersection_point.y) + ")",
                                    anchor=CENTER)
                                child_canvas.create_oval(
                                    intersection_point.x - 2.0,
                                    intersection_point.y - 2.0,
                                    intersection_point.x + 2.0,
                                    intersection_point.y + 2.0,
                                    outline="red",
                                    fill="red",
                                    width=2)
                            return
                else:
                    # If the line segment already exists in the sls, delete it
                    if lsegment[0] is not None:
                        findPreSuc.pre = None
                        findPreSuc.suc = None
                        findPreSuc(sls, lsegment[0].data)
                        sls.delete(lsegment[0].data)
                    else:
                        findPreSuc.pre = None
                        findPreSuc.suc = None
                        findPreSuc(sls, rsegment[0].data)
                        sls.delete(rsegment[0].data)

                    # Check for intersection with new successor and predecessor
                    if findPreSuc.pre is not None and findPreSuc.suc is not None and \
                            abs(findPreSuc.pre.data.index - findPreSuc.suc.data.index) > 1 and \
                            do_intersect(findPreSuc.pre.data.start, findPreSuc.pre.data.end,
                                    findPreSuc.suc.data.start,
                                    findPreSuc.suc.data.end):
                        print "Predecessor is", findPreSuc.pre.data.label, "{(", \
                            findPreSuc.pre.data.start.x, ",", findPreSuc.pre.data.start.y, "),(", \
                            findPreSuc.pre.data.end.x, ",", findPreSuc.pre.data.end.y, ")}"
                        print "Successor is", findPreSuc.suc.data.label, "{(", \
                            findPreSuc.suc.data.start.x, ",", findPreSuc.suc.data.start.y, "),(", \
                            findPreSuc.suc.data.end.x, ",", findPreSuc.suc.data.end.y, ")}"
                        print "Intersection Discovered6"
                        intersection_discovered = True
                        intersection_point = get_intersection_point(
                            findPreSuc.pre.data, findPreSuc.suc.data)
                        if automate_clicked:
                            if test is not None:
                                sls_canvas.delete(test)
                            test = sls_canvas.create_text(
                                window_width / 2,
                                20,
                                fill="darkblue",
                                font="Times 20 italic bold",
                                text="Intersection Discovered at (" +
                                str(intersection_point.x) + ", " +
                                str(intersection_point.y) + ")",
                                anchor=CENTER)
                            child_canvas.create_oval(
                                intersection_point.x - 2.0,
                                intersection_point.y - 2.0,
                                intersection_point.x + 2.0,
                                intersection_point.y + 2.0,
                                outline="red",
                                fill="red",
                                width=2)
                        return

        if not automate_clicked:
            button4.wait_variable(var)
            var.set(0)
        if intersection_discovered:
            return

        label = ""
        global test
        if sls.data is not None:
            sls_text = sls.print_tree(label)
            if test is not None:
                sls_canvas.delete(test)
            test = sls_canvas.create_text(window_width / 2,
                                          20,
                                          fill="darkblue",
                                          font="Times 20 italic bold",
                                          anchor=CENTER,
                                          text=sls_text)
            print label

        last_point = current_point.y

    print "This is a simple chain"
    global button4
    if test is not None:
        sls_canvas.delete(test)
    test = sls_canvas.create_text(window_width / 2,
                                  20,
                                  fill="green",
                                  font="Times 20 italic bold",
                                  anchor=CENTER,
                                  text="This is a simple chain")

    button4.config(state="disabled")
예제 #16
0
    def test_insert_same_key(self):
        node = Node(3, 'value')

        assert node.insert(3, 'value') is False