def test_peeking_at_stack_does_not_remove_item():
stack = Stack()
stack.push(1)
assert_equal(stack.empty(), False)
assert_equal(stack.peek(), 1)
assert_equal(stack.empty(), False)
def test_popping_from_stack_removes_item():
stack = Stack()
stack.push(1)
assert_equal(stack.empty(), False)
assert_equal(stack.pop(), 1)
assert_equal(stack.empty(), True)
def test_pushing_to_stack_adds_item_to_stack():
stack = Stack()
assert_equal(stack.empty(), True)
stack.push(1)
assert_equal(stack.empty(), False)
assert_equal(stack.peek(), 1)
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 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 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 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
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
def dfs(self, gray_func, black_func):
"""
图的深度遍历
:param gray_func:
:param black_func:
:return:
"""
gray_list = []
black_list = []
# 初始化
for key in self.__dict.iterkeys():
key.start_time = None
key.end_time = None
key.set_white()
# 开始遍历
counter = 0
for key in self.__dict.iterkeys():
if key.is_white():
dfs_stack = Stack()
key.set_gray()
key.start_time = counter
counter += 1
dfs_stack.push(key)
while not dfs_stack.empty():
cur_node = dfs_stack.pop()
gray_list.append(gray_func(key))
for end_node in self.__dict[cur_node]:
if end_node.is_white():
end_node.set_gray()
end_node.start_time = counter
counter += 1
dfs_stack.push(end_node)
cur_node.set_black()
black_list.append(black_func(cur_node))
cur_node.end_time = counter
counter += 1
return gray_list, black_list
def test_empty_returning_false_when_not_empty():
stack = Stack()
stack.push(1)
assert_equal(stack.empty(), False)
def test_empty_returning_true_when_empty():
stack = Stack()
assert_equal(stack.empty(), True)
