def test_pop():
queue = Queue()
queue.push(1)
assert queue.pop() == 1
assert queue.size == 0
queue.push(2)
assert queue.front() == 2
assert queue.size == 1
queue.push(3)
queue.push(4)
assert queue.pop() == 2
assert queue.size == 2
assert queue.pop() == 3
assert queue.pop() == 4
assert queue.size == 0
def test_on_case_from_hw2_task():
queue = Queue()
queue.push(2)
queue.push(4)
queue.push(6)
queue.push(8)
queue.push(0)
assert queue.pop() == 2
def bfs_iter(self, grp, src):
vtx = [0] * len(grp)
que = Queue()
vtx[src] = 1
que.push(src)
while len(que) > 0:
i = que.pop()
assert (vtx[i] == 1)
for j in grp[i]:
if vtx[j] == 0:
vtx[j] = 1
que.push(j)
return vtx
def bfs_iter(self, grp, src):
vtx = [0] * len(grp)
que = Queue()
vtx[src] = 1
que.push(src)
while len(que) > 0:
i = que.pop()
assert (vtx[i] == 1)
for j in grp[i]:
if vtx[j] == 0:
vtx[j] = 1
que.push(j)
return vtx
def main_bfs(self, grp, src):
vtx = [0] * len(grp)
dpt = [None] * len(grp)
que = Queue()
vtx[src] = 1
dpt[src] = 0
que.push(src)
while len(que) > 0:
i = que.pop()
assert (vtx[i] == 1)
for j in grp[i]:
# 只有首次遍历到的深度才是最小深度
if vtx[j] == 0:
vtx[j] = 1
dpt[j] = dpt[i] + 1
que.push(j)
return dpt
def main_bfs_iter(self, grp):
num = 0
for i in range(len(grp)):
for j in range(len(grp[0])):
if grp[i][j] == 1:
num += 1
que = Queue()
que.push((i, j))
while len(que) > 0:
a, b = que.pop()
if 0 <= a < len(grp) and 0 <= b < len(grp[0]) and grp[a][b] == 1:
grp[a][b] = 0
que.push((a, b + 1))
que.push((a + 1, b + 1))
que.push((a + 1, b))
que.push((a + 1, b - 1))
return num
def main_bfs(self, grp, src):
vtx = [0] * len(grp)
dpt = [None] * len(grp)
que = Queue()
vtx[src] = 1
dpt[src] = 0
que.push(src)
while len(que) > 0:
i = que.pop()
assert (vtx[i] == 1)
for j in grp[i]:
# 只有首次遍历到的深度才是最小深度
if vtx[j] == 0:
vtx[j] = 1
dpt[j] = dpt[i] + 1
que.push(j)
return dpt
def main_bfs_iter(self, grp):
num = 0
for i in range(len(grp)):
for j in range(len(grp[0])):
if grp[i][j] == 1:
num += 1
que = Queue()
que.push((i, j))
while len(que) > 0:
a, b = que.pop()
if 0 <= a < len(grp) and 0 <= b < len(
grp[0]) and grp[a][b] == 1:
grp[a][b] = 0
que.push((a, b + 1))
que.push((a + 1, b + 1))
que.push((a + 1, b))
que.push((a + 1, b - 1))
return num
def main(self, chst):
assert (isinstance(chst, dict) and len(chst) > 2) # makes sense
# build Huffman tree
hp = MinBinaryHeap(map(lambda (c, f): self.__class__.Node(f, c), chst.items()), lambda x: x.key)
while len(hp) > 1:
left = hp.pop()
right = hp.pop()
node = self.__class__.Node(left.key + right.key, None, left, right)
hp.push(node)
# check tree and prepare for code generation
assert (len(hp) == 1)
node = hp.pop()
assert (node.key == sum(map(lambda x: x[1], chst.items())) and node.value is None)
node.key = None
# generate Huffman code by traversing Huffman tree
que = Queue()
que.push(node)
while len(que) > 0:
node = que.pop()
if node.value is not None:
assert (isinstance(node.key, str) and isinstance(node.value, str))
chst[node.value] = node.key
assert (node.left is None and node.right is None)
elif node.key is None: # node is root
if node.left:
node.left.key = '0'
que.push(node.left)
if node.right:
node.right.key = '1'
que.push(node.right)
else:
assert (isinstance(node.key, str))
if node.left:
node.left.key = node.key + '0'
que.push(node.left)
if node.right:
node.right.key = node.key + '1'
que.push(node.right)
return chst
