Python Tree.insert方法代码示例

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
class TestTree(unittest.TestCase):

    def __init__(self, methodName, humanName, maxPts):
        super(TestTree, self).__init__(methodName)
        self.methodName = methodName
        self.humanName = humanName
        self.maxPts = maxPts
        self.points = 0

    def setUp(self):
        self.tree = Tree()

    def testInsert(self):
        self.assertEquals(self.tree.size(), 0)
        self.tree.insert(Node(7))
        self.assertEquals(self.tree.size(), 1)
        self.tree.bulk_insert(7,3,4,5,3,4,6,6,2,1,10)
        self.assertEquals(self.tree.size(), 12)
        self.assertEquals(self.tree.size(), 3)

    def testNothing(self):
        pass

    def __str__(self):
        return self.humanName

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
    def testTraverse(self):
        tree = Tree()
        for word in insert_queue:
            tree.insert(word)

        insert_queue.sort()
        self.assertEqual(tree.inorder_traverse(), " ".join(insert_queue))

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
    def test_exceptions(self):
        with self.assertRaises(ValueError):
            t = Tree("t", "T")
            t.insert('t', "T")

        with self.assertRaises(KeyError):
            t = Tree('t', "T")
            t.find('z')        

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
    def testSearch(self):
        tree = Tree()
        for word in insert_queue:
            tree.insert(word)

        for i in insert_queue:
            self.assertEqual(tree.search(i), i)

        self.assertEqual(tree.search("not found"), None)

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def test_tree_find(self):
     'Verify find method, with data and without'
     t = Tree('D')
     for c, i in (('F', [6,7,8]),('C', 3), ('G', dict(one=1, two=2)), ('A', 1), ('E', 5), ('B', 2)):
         t.insert(c, i)
     self.assertEqual(t.find('D'), None)
     self.assertEqual(t.find('A'), 1)
     self.assertEqual(t.find('F'), [6,7,8])
     self.assertEqual(t.find('G'), {'one':1, 'two':2})
     self.assertRaises(KeyError, t.find, 'Z')

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
    def testDelete(self):
        tree = Tree()
        copy_q = copy(insert_queue)
        for word in copy_q:
            tree.insert(word)

        tree.delete(copy_q[-1])
        self.assertEqual(tree.search(copy_q[-1]), None)

        copy_q.pop()
        copy_q.sort()
        self.assertEqual(tree.inorder_traverse(), " ".join(copy_q))

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
class Test(unittest.TestCase):


    def setUp(self):
        self.test = Tree("D", ord("D"))
        for c in "BJQKFAC":
            self.test.insert(c, ord(c)) 


    def testTree(self):
        self.assertEqual(self.test.answer(70), 'F')
        self.assertEqual(self.test.answer(81), 'Q')
        
    def testExceptions(self):
        self.assertRaises(KeyError, self.test.find(99))

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def testInsert(self):
     tree = Tree()
     temp = "b"
     tree.insert(temp)
     self.assertEqual(tree.head.item, temp)
     temp = "a"
     tree.insert(temp)
     self.assertEqual(tree.head.left.item, temp)
     temp = "cat"
     tree.insert(temp)
     self.assertEqual(tree.head.right.item, temp)

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
    return None
def getpath(root,node):
    l =[]
    r = []
    if root == node:
        return [root]
    if root.left:
        l = getpath(root.left,node)
    if root.right:
        r = getpath(root.right,node)
    if l != [] or r != []:
        return [root] + l + r
    return []

def left_most(root):
    temp = root
    while temp.left:
        temp = temp.left
    return temp

t = Tree()
for i in range(15):
    t.insert(i)
print t.inorder(t.root)
for i in range(15):
    n = t.getNodeinstance(i)
    if inorder_next(t.root,n) != None:
        print n.val,"->",inorder_next(t.root,n).val
    else:
        print n.val,"->",None

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
from tree import Tree

print("Tree test")

t = Tree()
t.insert(1, t)
t.insert(30, t)
t.insert(15, t)

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
	def show(self, result):
		by_product = {}
		by_id = {}
		class TreeBug(dict):
			def __init__(self, b):
				for i in b:
					self[i] = b[i]
			def __str__(self):
				res = ""
				if 'notmybug' in self:
					res = '\033[33m'
				res += str(self['id']) + " "
				res += str(self['priority']) + " "
				res += str(self['estimated_time']) + " "
				res += str(self['status'][:3]) + " "
				res += str(self['severity'][:3]) + " "
				res += str(self['summary'].encode('utf-8')) + " "
				res += str(self['blocks']) + " "
				creat = datetime.strptime(str(self['creation_time']).split('T')[0], "%Y%m%d").date()
				creat += timedelta(days=severity_importance[self['severity']])
				if self['severity'] != "enhancement":
					res += str((creat - date.today()).days)
				if 'notmybug' in self:
					res += '\033[0m'
				#res += str(self['blocklist']) + " "
				return res

			def equals(self, b):
				return self['id'] == b['id']
			def is_above(self, b):
				return self.is_parent_of(b)
			def is_parent_of(self, b):
				return self['id'] in b['blocklist']
			def update(self, b):
				pass
		class Walker(object):
			def __init__(self):
				self.parents = []
			def _update_parents(self, bug):
				while len(self.parents):
					parent = self.parents[-1]
					self.parents = self.parents[:-1]
					if parent.is_parent_of(bug):
						self.parents.append(parent)
						break
		class TreePrinter(Walker):
			def __call__(self, bug):
				self._update_parents(bug)
				print '{} {}'.format('  ' * len(self.parents), str(bug))
				self.parents.append(bug)
				return True;
		class TreeEstimator(Walker):
			def __call__(self, bug):
				self._update_parents(bug)
				for parent in self.parents:
					parent['estimated_time'] += bug['estimated_time']
				self.parents.append(bug)
				return True;

		mybugs = []
		for bug in result:
			mybugs.append(TreeBug(bug))
		result = None

		for bug in mybugs:
			by_product.setdefault(bug['product'], [])
			by_product[bug['product']].append(bug)
			by_id[bug['id']] = bug

		for bug in mybugs:
			res = []
			self.addblock(by_id, bug, res)
			bug['blocklist'] = res
		for product in by_product:
			print product
			bugtree = Tree()
			#by_product[product] = sorted(by_product[product], cmp=bugcmp)
			for bug in sorted(by_product[product], cmp=bugcmp):
				bugtree.insert(bug)
			bugtree.walk(TreeEstimator())
			bugtree.walk(TreePrinter())
			print

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def test_tree_no_right(self):
     t = Tree('D', 4)
     for c, i in (('C', 3), ('A', 1), ('B', 2)):
         t.insert(c, i)
     self.assertEqual(list(t.walk()), ['A', 'B', 'C', 'D'])

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def test_insert(self):
     t = Tree("t", "T")
     t.insert('u', "U")
     observed = list(t.walk())
     expected = ['t', 'u']
     self.assertEqual(observed, expected)

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def test_find_lowest_common_ancestor(self):
     tree = Tree()
     tree.insert(20)
     tree.insert(8)
     tree.insert(22)
     tree.insert(4)
     tree.insert(12)
     tree.insert(10)
     tree.insert(14)
     self.assertEqual(find_lowest_common_ancestor(tree.root, 4, 14).data, 8)

# 需要导入模块: from tree import Tree [as 别名]
# 或者: from tree.Tree import insert [as 别名]
 def test_tree_both_lr(self):
     'Test tree with both L and R nodes. Also no data passed in.'
     t = Tree('D')
     for c in 'FGCAEB':
         t.insert(c)
     self.assertEqual(list(t.walk()), ['A', 'B', 'C', 'D', 'E', 'F', 'G'])