Python BST.inorder方法代码示例

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def test_new_tree():
    from bst import BST
    new_bst = BST()
    new_bst.insert(100)
    new_bst.insert(25)
    new_bst.insert(30)
    new_bst.insert(40)
    assert [x for x in new_bst.inorder(new_bst.head)] == [25, 30, 40, 100]

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def test_inorder():
    nums = range(1, 200)
    random.shuffle(nums)
    bst = BST()
    for n in nums:
        bst.add(n)
    nums.sort()

    assert bst.inorder() == sorted(nums)

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def bstsort(l):
    arbol = BST()
    # Generamos nuestra estructura 
    # de datos auxiliar
    
    while l:
        # Vaciamos la lista en el arbol
        item = l.pop()
        arbol.add(item)
    
    l.extend(arbol.inorder())

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
from bst import BST, Node

def sorted_array_to_bst(array):
	return _sorted_array_to_bst(array, 0, len(array)-1)

def _sorted_array_to_bst(array, left, right):
	if left == right:
		return Node(array[left])
	if left > right:
		return None

	mid = (left + right) / 2
	root = Node(array[mid])
	root.left = _sorted_array_to_bst(array, left, mid-1)
	root.right = _sorted_array_to_bst(array, mid+1, right)
	return root

if __name__ == "__main__":
	array = [0, 1, 2, 3, 4, 5]
	tree = BST(sorted_array_to_bst(array))
	tree.inorder()

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def createConcordance(inputFile, stopWords, outputFile):

    #declare data structures
    stopSet = HashSet(3500)
    dictionary = HashDictionary(10000)
    bst = BST()

    #declare regular expressions
    newLine = re.compile(r'\n')
    exprSpaces = re.compile(r'\s')
    dhyp = re.compile('--')
    notChars = re.compile('\W|-')
    
    #populate hashset with stop words
    stopWords = open(stopWords, 'r')
    for stop in stopWords:
        x = newLine.search(stop)
        stop = stop[:x.start()]
        if stop == "":
            break
        stopSet.add(stop)
    stopWords.close()
    
    #open the input and process into words
    f = open(inputFile, 'r')
    lineNum = 0
    while True:
        line = f.readline()
        lineNum += 1
        if line == "":
            break

        #split lines
        m = dhyp.split(line)
        alist = []
        for i in range(len(m)):
            g = exprSpaces.split(m[i])
            alist = alist + g
            
        #strip down to words
        print alist
        for word in alist:
            if word == None:
                pass
            else:
                word = string.lower(word)
                while True:
                    n = notChars.search(word)
                    if len(word) <= 0:
                        break
                    elif n != None:
                        if n.start() == 0:
                            word = word[n.end():]
                        else:
                            word = word[:n.start()]
                    else:
                        break
                            
                #check if word is stop word
                if not stopSet.contains(word) and len(word) > 0:
                    #if word isn't already in dictionary
                    if dictionary.search(word) == None:
                        linkedValue = LinkedIndexedList()
                        dictionary.store(word, linkedValue)
                        dictionary.search(word).append(lineNum)
                        bst.add(word)
                    #if the word is in the dictionary
                    else:
                        dictionary.search(word).append(lineNum)
    f.close()

    #open output and use BST to print out words
    #   in alphabetical order
    output = open(outputFile, 'w')
    lyst = bst.inorder()
    temp = None
    for item in lyst:
        temp = dictionary.search(item)
        output.write(item + " - " + str(temp)+"\n")
    output.close()

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
from bst import BST
from bst import Node

if __name__ == "__main__":
	root = Node(5)
	bst = BST()
	bst.insert(root, Node(2))
	bst.insert(root, Node(3))
	bst.insert(root, Node(4))
	print "Inorder traversal"
	bst.inorder(root)
	print "Preorder traversal"
	bst.preorder(root)
	print "Postorder traversal"
	bst.postorder(root)

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def test_init_list():
    nums = range(0, 10)
    t = BST(keys=nums)
    assert t.inorder() == nums

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def test_init_empty():
    t = BST()
    assert t.inorder() == []

# 需要导入模块: from bst import BST [as 别名]
# 或者: from bst.BST import inorder [as 别名]
def test_unique_queue():
    BST(keys=[1])
    t = BST(keys=[2])
    assert t.inorder() == [2]