def setUp(self):
# Create stacks for the tests to use
self.new = Stack()
self.empty = Stack()
self.empty.push('hi')
self.empty.pop()
# Don't add in ascending or descending order
self.non_empty = Stack()
self.non_empty.push(5)
self.non_empty.push(2)
self.non_empty.push(7)
self.non_empty.push(2)
def midorder(self, f):
"""
B树中序遍历
:param f:
:return:
"""
result = []
stack = Stack()
cur_node = self.__root
if cur_node.is_leaf:
return map(f, cur_node.keys)
while True:
if cur_node.is_leaf:
# 到叶节点了，开始把叶节点的所有关键字都遍历掉
result.extend(map(f, cur_node.keys))
# 开始从栈中取元素，遍历下一个节点叶节点
if stack.empty():
return result
cur_node, i = stack.pop()
result.append(f(cur_node.keys[i]))
if i < len(cur_node) - 1:
stack.push((cur_node, i + 1))
cur_node = cur_node.childs[i + 1]
else:
stack.push((cur_node, 0))
cur_node = cur_node.childs[0]
return result
def test_constructs(self):
s = Stack()
s1 = Slice(1, 2, 3)
s.push(s1)
assert s[0] == s1
assert isinstance(s[0], Slice)
assert s[0].__str__() == '1,2,3 R0'
def brackets_match(string):
"""Check if all brackets in the string are correctly matched.
Return True if they are, otherwise False.
Only consider round and square brackets, i.e. () and []. For example:
>>> brackets_match("No brackets is fine")
True
>>> brackets_match("After ( and [ comes ] and )")
True
>>> brackets_match("After ( and [ it cannot be ) and ]")
False
>>> brackets_match("A ( without closing bracket")
False
>>> brackets_match("A ] without opening bracket")
False
>>> brackets_match("Snarks are rarely seen (according to Smith (1999)).")
True
"""
expected = Stack()
for character in string:
if character == "(":
expected.push(")")
elif character == "[":
expected.push("]")
elif character == ")" or character == "]":
if expected and character == expected.top():
expected.pop()
else:
return False
return expected.is_empty()
def main():
print "\ncheck stack"
stack = Stack(1, 2, 34, 5)
for x in range(0, 5):
stack.push(x)
print stack
for x in range(0, 15):
print "".join(["size=", str(len(stack)), " cur_node=", str(stack.pop())])
print "\ncheck queue"
queue = Queue(1, 2, 34, 5)
for x in range(0, 5):
queue.enter(x)
print stack
for x in range(0, 15):
print "".join(["size=", str(len(queue)), " cur_node=", str(queue.exit())])
print "\ncheck BSTree"
tree = BSTree(1, 2, 34, 5)
print tree
print tree.find(10)
print tree.find(5)
print tree.max()
print tree.min()
print tree.successor(34)
print tree.successor(5)
print tree.predecessor(1)
print tree.predecessor(2)
def test_stack_push(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
self.assertEqual(stk.is_empty(), False)
self.assertEqual(stk.peek(), v)
self.assertEqual(stk.pop(), v)
def test_stack_init(self):
stk = Stack()
self.assertEqual(stk.size(), 0)
self.assertEqual(stk.is_empty(), True)
with self.assertRaises(IndexError):
stk.pop()
with self.assertRaises(IndexError):
stk.peek()
def stack_create(domain, name, meta_path=None, from_stack=None):
"""
Create a new stack. From old one if specified.
"""
# get the meta_path from .gachetterc
meta_path = meta_path if 'meta_path' not in env else env.meta_path
if not meta_path:
abort("Please specify a `meta_path` or use a config file to define it")
new_stack = Stack(domain, name, meta_path=meta_path)
if not new_stack.is_persisted():
if from_stack:
old_stack = Stack(domain, from_stack, meta_path=meta_path)
new_stack.clone_from(old_stack)
else:
new_stack.persist()
def test_stack_peek(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
for v in random_values[::-1]:
self.assertEqual(stk.peek(), v)
stk.pop()
def test_stack_reverse(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
stk.reverse()
for v in random_values:
self.assertEqual(stk.peek(), v)
stk.pop()
def test_stack_size(self):
stk = Stack()
random_values = get_random_values()
for i, v in enumerate(random_values):
stk.push(v)
self.assertEqual(stk.size(), i + 1)
for i in range(len(random_values)):
stk.pop()
self.assertEqual(stk.size(), len(random_values) - i - 1)
def dec_to_bin(dec):
tmp = Stack()
binary = ""
while dec != 0:
tmp.push(dec % 2)
dec //= 2
while not tmp.isEmpty():
binary += str(tmp.pop())
return binary
def test_stack_reversed(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
reversed_stk = reversed(stk)
for v in random_values:
self.assertEqual(reversed_stk.peek(), v)
reversed_stk.pop()
self.assertEqual(stk.size(), len(random_values))
def test_stack_copy(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
copied_stk = stk.copy()
for v in random_values[::-1]:
self.assertEqual(copied_stk.peek(), v)
copied_stk.pop()
self.assertEqual(stk.size(), len(random_values))
def base_converter(dec_number, base):
digits = "0123456789ABCDEF"
tmp = Stack()
string = ""
while dec_number != 0:
tmp.push(dec_number % base)
dec_number //= base
while not tmp.isEmpty():
string += digits[tmp.pop()]
return string
def test_stack_is_empty(self):
stk = Stack()
random_values = get_random_values()
self.assertEqual(stk.is_empty(), True)
for v in random_values:
stk.push(v)
self.assertEqual(stk.is_empty(), False)
for v in random_values[::-1]:
self.assertEqual(stk.is_empty(), False)
stk.pop()
self.assertEqual(stk.is_empty(), True)
def dec_to_bin(dec):
s = Stack()
while(dec>0):
s.push(dec%2)
dec // 2
binary = 0
for i in range(s.size()):
num = s.pop()
binary += num*(10**s.size())
return binary
def dec_to_bin(dec):
binary = ''
s = Stack()
while dec != 0:
tmp = dec % 2
dec = dec // 2
s.push(tmp)
while s.size() != 0:
a = s.pop()
binary += str(a)
return binary
def dec_to_bin(dec):
# Finish the function
s=Stack()
while dec!=0:
s.push(dec%2)
dec=dec//2
binary=[]
while not s.isEmpty():
binary.append(s.pop())
return binary
def base_converter(dec_number, base):
digits = "0123456789ABCDEF"
s=Stack()
while dec_number!=0:
s.push(digits[dec_number%base])
dec_number=dec_number//base
string=''
while not s.isEmpty():
string=string+s.pop()
return string
def test_stack_pop(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
for v in random_values[::-1]:
stk.pop()
self.assertEqual(stk.is_empty(), True)
with self.assertRaises(IndexError):
stk.pop()
with self.assertRaises(IndexError):
stk.peek()
def preorder(self, f):
result = []
stack = Stack(self.__root)
while True:
cur_node = stack.pop()
# 栈中没有元素的时候就表示所有的元素都已经遍历完了
if cur_node is None:
break
result.append(f(cur_node.value))
if cur_node.left is not None:
stack.push(cur_node.left)
if cur_node.right is not None:
stack.push(cur_node.right)
return result
def add_to_stack(domain, name, version, file_name, meta_path, stack_version):
"""
Add created package to stack and reference packages.
<name> actual name of the package.
<version> version of the package.
<file_name> exact file_name of the package (versioned, architecture...).
<meta_path> path to the stacks and other meta information related to package
<stack_version> version of the stack to attach the package to.
"""
# get the meta_path from .gachetterc
meta_path = meta_path if 'meta_path' not in env else env.meta_path
stack = Stack(domain, stack_version, meta_path=meta_path)
stack.add_package(name, version, file_name)
def test_stack_reversed_with_override(self):
self.assertEqual(list(reversed([123, 456])), [456, 123])
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
reversed_stk = reversed(stk)
for v in random_values:
self.assertEqual(reversed_stk.peek(), v)
reversed_stk.pop()
self.assertEqual(stk.size(), len(random_values))
self.assertEqual(list(reversed([123, 456])), [456, 123])
def dec_to_bin(dec):
s = Stack()
n = dec
if n == 0:
s.push(n % 2)
n = n // 2
while n > 0:
s.push(n % 2)
n = n // 2
number = s.size()
binary = ''
for i in range(number):
binary = binary + str(s.pop())
return binary
def midorder(self, f):
result = []
stack = Stack(self.__root)
cur_node = self.__root.left
# 第一个阶段首先把所有树左边的节点放进栈里,这个时候并不遍历
# 第二个阶段的时候由于左节点遍历了之后,再遍历右节点
while not stack.empty() or cur_node is not None:
# 第二个判断条件比较重要,因为如果根节点没有左子树,这个时候栈就是空的,会直接退出循环
if cur_node is not None:
stack.push(cur_node)
cur_node = cur_node.left
else:
cur_node = stack.pop()
result.append(f(cur_node.value))
cur_node = cur_node.right
return result
def base_converter(dec_number, base):
digits = "0123456789ABCDEF"
s = Stack()
n = dec_number
while n > 0:
number = n % base
if number > 9:
s.push(digits[number])
else:
s.push(n % base)
n = n // base
number = s.size()
string = ''
for i in range(number):
string = string + str(s.pop())
return string
def dec_to_bin2(dec):
s = Stack()
i = 0
for j in range(10000):
if(dec // (2**j) == 0):
i = j
break
binary = 0
for k in range(i):
k = i - k
if(dec % (2 ** k) // (2 ** (k-1)) == 1):
s.push(1)
else:
s.push(0)
for l in range(s.size()):
binary += s.pop() * (10 ** l)
return binary
def base_converter(dec, base):
binary = ''
s = Stack()
while dec != 0:
if base > 16 or base < 2: #若base輸入值不符合範圍，輸出error
return "error"
tmp = dec % base
dec = dec // base
if tmp >= 10:
d = tmp % 10
tmp = chr(65 + d)
s.push(tmp)
while s.size() != 0:
a = s.pop()
binary += str(a)
return binary
def midorder(self, f):
"""
中序遍历
:param f:访问一个节点的时候要对节点进行处理的函数
:return:
"""
result = []
stack = Stack(self.__root)
cur_node = self.__root.left
# 第一个阶段首先把所有树左边的节点放进栈里,这个时候并不遍历
# 第二个阶段的时候由于左节点遍历了之后,再遍历右节点
while not stack.empty() or cur_node is not self.Nil:
# 第二个判断条件比较重要,因为如果根节点没有左子树,这个时候栈就是空的,会直接退出循环
if cur_node is not self.Nil:
stack.push(cur_node)
cur_node = cur_node.left
else:
cur_node = stack.pop()
result.append(f(cur_node))
cur_node = cur_node.right
return result
