import math
class NODE():
def __init__(self, key):
self.key = key
self.left = self
self.right = self
self.parent = None
self.child = None
self.degree = 0
self.mark = False
class FIB_HEAP():
def __init__(self):
self.num = 0
self.min = None
self.rootList = None
class DL_LIST():
def __init__(self):
self.nil = NODE(None)
self.nil.right = self.nil
self.nil.left = self.nil
def DL_LIST_SEARCH(L, k):
x = L.nil.right
while x != L.nil and x.key != k:
x = x.right
return x
def DL_LIST_INSERT(L, x):
x.right = L.nil.right
L.nil.right.left = x
L.nil.right = x
x.left = L.nil
def DL_LIST_INSERT_BEFORE(L, x, y):
y.left = x.left
y.right = x
x.left.right = y
x.left = y
def DL_LIST_DELETE(L, x):
x.left.right = x.right
x.right.left = x.left
def DL_LIST_UNION(L1, L2):
head1 = L1.nil.right
tail1 = L1.nil.left
head2 = L2.nil.right
tail2 = L2.nil.left
tail1.right = head2
head2.left = tail1
tail2.right = L1.nil
L1.nil.left = tail2
L2.nil.left = None
L2.nil.right = None
def DL_LIST_PRINT(L):
y = L.nil.right
while y != L.nil:
print(y.key, y.mark, y.degree)
if y.child != None:
print("---------child of ", y.key)
DL_LIST_PRINT(y.child)
print("----------child end")
y = y.right
def FIB_HEAP_INSERT(H, x):
x.parent = None
x.child = None
x.degree = 0
x.mark = False
if H.min == None:
H.root = DL_LIST()
DL_LIST_INSERT(H.root, x)
H.min = x
else:
DL_LIST_INSERT_BEFORE(H.root, H.min, x)
if x.key < H.min.key:
H.min = x
H.num = H.num + 1
def FIB_HEAP_UNION(H1, H2):
H = FIB_HEAP()
H.min = H1.min
DL_LIST_UNION(H.root, H2.root)
if (H1.min == None) or (H2.min != None and H2.min.key < H1.min.key):
H.min = H2.min
H.num = H1.num + H2.num
H1.root = None
H1.min = None
H2.root = None
H2.min = None
return H
def FIB_HEAP_EXTRACT_MIN(H):
z = H.min
if z != None:
if z.child != None:
x = z.child.nil.right
while x != z.child.nil:
x.parent = None
y = x.right
DL_LIST_INSERT_BEFORE(H.root, H.min, x)
x = y
DL_LIST_DELETE(H.root, z)
if H.root.nil.right == H.root.nil and H.root.nil.left == H.root.nil:
H.min = None
else:
H.min = z.right
CONSOLIDATE(H)
H.num = H.num -1
return z
def D(num):
return int(math.log(num, 2))+1
def CONSOLIDATE(H):
A = [None for i in range(D(H.num)+1)]
w = H.min
last = w.left
flag = True
while flag:
x = w
w = w.right
if x == H.root.nil:
continue
elif x == last:
flag = False
d = x.degree
while A[d] != None:
y = A[d]
if x.key > y.key:
temp = x
x = y
y = temp
FIB_HEAP_LINK(H, y, x)
A[d] = None
d = d + 1
A[d] = x
H.min = None
for i in range(0, D(H.num)+1):
if A[i] != None:
if H.min == None:
H.root = DL_LIST()
DL_LIST_INSERT(H.root, A[i])
H.min = A[i]
else:
DL_LIST_INSERT_BEFORE(H.root, H.min, A[i])
if A[i].key < H.min.key:
H.min = A[i]
def FIB_HEAP_LINK(H, y, x):
DL_LIST_DELETE(H.root, y)
if x.child == None:
x.child = DL_LIST()
DL_LIST_INSERT(x.child, y)
x.degree = x.degree + 1
y.parent = x
y.mark = False
def FIB_HEAP_DECREASE_KEY(H, x, k):
if k > x.key:
raise("new key is greater than current key")
x.key = k
y = x.parent
if y != None and x.key < y.key:
CUT(H, x, y)
CASCADING_CUT(H, y)
if x.key < H.min.key:
H.min = x
def CUT(H, x, y):
DL_LIST_DELETE(y.child, x)
y.degree = y.degree - 1
DL_LIST_INSERT_BEFORE(H.root, H.min, x)
x.parent = None
x.mark = False
def CASCADING_CUT(H, y):
z = y.parent
if z != None:
if y.mark == False:
y.mark = True
else:
CUT(H, y, z)
CASCADING_CUT(H, z)
def FIB_HEAP_DELETE(H, x):
FIB_HEAP_DECREASE_KEY(H, x, -float("inf"))
FIB_HEAP_EXTRACT_MIN(H)
if __name__ == "__main__":
H = FIB_HEAP()
node24 = NODE(24)
FIB_HEAP_INSERT(H, node24)
node17 = NODE(17)
FIB_HEAP_INSERT(H, node17)
node3 = NODE(3)
FIB_HEAP_INSERT(H, node3)
node23 = NODE(23)
FIB_HEAP_INSERT(H, node23)
node7 = NODE(7)
FIB_HEAP_INSERT(H, node7)
node39 = NODE(39)
FIB_HEAP_INSERT(H, node39)
node18 = NODE(18)
FIB_HEAP_INSERT(H, node18)
node52 = NODE(52)
FIB_HEAP_INSERT(H, node52)
node38 = NODE(38)
FIB_HEAP_INSERT(H, node38)
node41 = NODE(41)
FIB_HEAP_INSERT(H, node41)
node30 = NODE(30)
FIB_HEAP_INSERT(H, node30)
node35 = NODE(35)
FIB_HEAP_INSERT(H, node35)
node26 = NODE(26)
FIB_HEAP_INSERT(H, node26)
node46 = NODE(46)
FIB_HEAP_INSERT(H, node46)
FIB_HEAP_LINK(H, node39, node18)
FIB_HEAP_LINK(H, node41, node38)
FIB_HEAP_LINK(H, node35, node26)
node39.mark = True
FIB_HEAP_LINK(H, node38, node3)
FIB_HEAP_LINK(H, node52, node3)
FIB_HEAP_LINK(H, node18, node3)
FIB_HEAP_LINK(H, node30, node17)
FIB_HEAP_LINK(H, node46, node24)
FIB_HEAP_LINK(H, node26, node24)
node18.mark = True
node26.mark = True
print("init ********************")
DL_LIST_PRINT(H.root)
print("insert ******************")
node21 = NODE(21)
FIB_HEAP_INSERT(H, node21)
DL_LIST_PRINT(H.root)
print("extract******************")
FIB_HEAP_EXTRACT_MIN(H)
DL_LIST_PRINT(H.root)
print("decrease*****************")
FIB_HEAP_DECREASE_KEY(H, node46, 15)
DL_LIST_PRINT(H.root)
print("decrease-----------------")
FIB_HEAP_DECREASE_KEY(H, node35, 5)
DL_LIST_PRINT(H.root)
print("delete*******************")
FIB_HEAP_DELETE(H, node18)
DL_LIST_PRINT(H.root)
算法导论第十九章习题解答
3星 · 超过75%的资源 需积分: 0 183 浏览量
更新于2016-05-30
收藏 6KB RAR 举报
《算法导论》是计算机科学领域的一本经典著作,它深入浅出地介绍了各种重要的算法,并提供了详尽的分析和实现。第十九章通常聚焦于图算法,因为图在计算机科学中有广泛的应用,如网络路由、社交网络分析、最短路径问题等。本章节的习题解答将涵盖以下几个关键知识点:
1. 图的基本概念:包括图的定义、有向图与无向图、加权图、树(一种特殊的图)以及图的表示方法,如邻接矩阵和邻接表。
2. 深度优先搜索(DFS):这是一种遍历或搜索树或图的方法,从一个节点开始,探索尽可能深的分支,直到找到目标或回溯到起点。
3. 广度优先搜索(BFS):另一种图搜索策略,从根节点开始,逐层探索所有相邻节点,然后继续下一层次的节点。
4. 最短路径问题:Dijkstra算法是解决单源最短路径问题的经典算法,适用于加权无环图。Floyd-Warshall算法则可以处理所有对之间的最短路径,适用于有权图。
5. 最小生成树:Prim算法和Kruskal算法是构造给定图的最小生成树的常用方法,它们都保证了生成树的所有边的权重之和最小。
6. 拓扑排序:对于有向无环图(DAG),拓扑排序可以得到一个线性的节点顺序,使得对于每一条有向边 (u, v),节点 u 在排序结果中都出现在节点 v 之前。
7. 强连通分量:在有向图中,如果两个节点互相可达,则称它们属于同一个强连通分量。Tarjan算法或Kosaraju算法可用于找出这些分量。
8. 桥和割点:桥是指删除后会将图分割成两个或更多个不连通部分的边;割点则是删除后会增加连通分量数量的节点。
在提供的"chapter19"文件中,你可能会看到以上知识点的具体习题解答,包括代码实现和解题思路。对于那些没有给出代码或思路的习题,可能是作者也未能解决或仍在思考中。学习这些习题解答有助于加深对图算法的理解,并提升编程解决问题的能力。在实际应用中,理解并掌握这些算法可以有效解决复杂问题,优化计算效率。
pokeyode
- 粉丝: 36
- 资源: 26
最新资源
- 基于Selenium页面爬取某东商品价格监控:自定义商品价格,降价邮件微信提醒资料齐全+详细文档+源码.zip
- 基于selenium爬取通过搜索关键词采用指定页数的商品信息资料齐全+详细文档+源码.zip
- 基于今日头条自动发文机器人,各大公众平台采集爬虫资料齐全+详细文档+源码.zip
- 基于集众多数据源于一身的爬虫工具箱,旨在安全快捷的帮助用户拿回自己的数据,工具代码开源,流程透明、资料齐全+详细文档+源码.zip
- 基于拼多多爬虫,爬取所有商品、评论等信息资料齐全+详细文档+源码.zip
- 基于爬虫从入门到入狱资料齐全+详细文档+源码.zip
- 基于爬虫学习仓库,适合零基础的人学习,对新手比较友好资料齐全+详细文档+源码.zip
- 基于天眼查爬虫资料齐全+详细文档+源码.zip
- 基于千万级图片爬虫、视频爬虫资料齐全+详细文档+源码.zip
- 基于支付宝账单爬虫资料齐全+详细文档+源码.zip
- 基于SpringBoot+Vue3实现的在线考试系统(三)代码
- 数组-.docx cccccccccccccccccccccc
- Ruby技巧中文最新版本
- Ruby袖珍参考手册pdf英文文字版最新版本
- 融合导航项目全套技术资料100%好用.zip
- 四足机器人技术进展与应用场景