python检查网图是否有环_哄好面试官系列-1：比较2个python dict（多级）是否相同！...

最新推荐文章于 2024-05-23 11:41:41 发布

weixin_39827315

最新推荐文章于 2024-05-23 11:41:41 发布

阅读量162

点赞数

文章标签： python检查网图是否有环

工作面试是个很有意思的过程, 面试经常是一个对未知领域初步了解的最好时机(对双方都是), 面试官和面试人通常也会尽力在最短的时间里表达/接受尽可能多的信息.

因此面试题一般也是比较有趣的: 它浓缩了日常工作中的典型和有挑战性的问题, 而又不会带有太多日常工作中的繁琐.

在技术面试中, 要哄好面试官, 最重要的无疑是能把一个问题解释的完善严谨.

于是打算收集一些有趣的问题, 跟大家分享. 本次先唠唠这个:

问题: 比较2个多级dict是否相同

2个多级 dict 可以看成2个树的对比, 此类问题应该在刷题网站上有不少了, 似乎用树的遍历就可以了, 然而可达鸭认为事情并不简单. 在深入答案之前, 我们先明确下问题的描述:

一个 dict 中有多个key, 每个key对应一个子 dict . 为了简化问题, 假设 dict 中的key对应的value都是 dict , 没有其他类型.
如果能够用来访问 a 的所有的key也可以用来访问 b , 就认为2个dict相同, 例如:
a = {'foo':{'bar':{}}}; b = {'foo':{'bar':{}}} 就是一对相同的dict:
a['foo'] 和 b['foo'] 都存在.
a['foo']['bar'] 和 b['foo']['bar'] 也都存在.

思路: 递归

比较2个 dict 同构的思路很直接:

对于2个 dict : a 和 b , 先比较这2个 dict 各自的key的集合一致, 如果不一致肯定2个 dict 不一样.
再逐个对比每个key对应的子 dict 是否一样. 直到遍历完所有的子 dict .

def eq(a, b): for k in set(a) | set(b): if k not in a or k not in b: return False if not eq(a[k], b[k]): return False return Trueprint eq({}, {'x':{}}) # Falseprint eq({'x':{}}, {'x':{}}) # True

上面的代码差不多可以把大部分面试官哄到6成满意度.

但在实际使用中, 上面的代码还不太完善, 因为 dict 构成的图的节点之间可能存在 环形引用的情况 , 如果有环, 上面的代码就会出现调用栈溢出. 所以在上面的代码基础上, 还需要加入有对环的处理.

几乎所有的语言对函数的递归调用层数都有限制, 例如python的限制是1000.

处理有环的情况

用python来举例描述2个有环的 dict 结构, 如下:

a = {}b = {}a['x'] = {} # a1a['x']['x'] = ab['x'] = {} # b1b['x']['x'] = {} # b2b['x']['x']['x'] = b

画出上面2个图的引用关系是酱的(其中a1, b1, b2等用来表示a, b中其他的子table):

进群：960410445 即可获取源文件！

这里我们认为 a 和 b 是 访问相等 的: 因为对于访问者来说, 无法区分 a 和 b 的差别: 能用来访问 a 的路径, 也可以用来访问 b , 反之也一样 :

对于 a 和 b 来说:

a 和 b 都是合法的a['x'] 和 b['x'] 都是合法的a['x']['x'] 和 b['x']['x'] 都是合法的a['x']['x']['x'] 和 b['x']['x']['x'] 都是合法的

在这个有环的例子中, 可以看出:

肯定存在一些公共路径是无限长的.

现在我们需要改进算法, 检查出环形的路径并及时终止递归遍历.

如果某个路径在 a 中走到一个环上, 但在 b 中没有在一个环上, 就不用做特殊处理, 这种情况会自然的结束递归.
需要处理的是一个路径p在 a , b 上都对应到一个环的情况.

还是拿上面的各自成环的 a , b 为例, 对于一个无限长的公共路径p, p = [x, x, x...] , 它的每一步都通过 key=x 访问到下一个子 dict . 这有, 它的每一步分别访问到的 a , b 上的节点如下 ( a0 和 b0 分别是a和b的根节点. a1 , b2 等是其他的节点:

a -> a0, b0  a1, b1  a0, b2  a1, b0  a0, b1

观察下上面的步骤可以发现, 最后路径p又会回到a0, b0的位置.

因为节点对的数量是有限的, 最多不超过 |a| * |b| 个( |a| 是a中的节点数), 那么如果一个路径p是无限长的, 那最终一定会在再次回到一个已经访问过的节点对 (上例中的 a0, b0 ).

找到这个规律, 我们就有了剔除无限长路径的思路:

比较2个(可能有环型引用的)dict的算法:

遍历(广度优先/深度优先都可以), 枚举出所有查询路径p
对一个路径p, 检查它的一步 p[i] 是否都能在 a 和 b 中走通, 如果不能, 则 a 和 b 存在一个不一致的路径, 失败退出.
过滤出无限长的路径:
记录路径p在图 a , b 中经过的 节点对 , 如果 p[i] 访问到一个已经经过的 节点对 , 则认为这个路径是环的, 不需要继续检查了, 回溯去检查其他路径.

python实现

def eq(a, b, walked=None): walked = walked or {} if (id(a), id(b)) in walked: return True walked[(id(a), id(b))] = True for k in set(a) | set(b): if k not in a or k not in b: return False if not eq(a[k], b[k], walked): return False return Trueprint eq({}, {'x':{}}) # Falseprint eq({'x': {}}, {'x':{}}) # Truea = {}b = {}a['x'] = ab['x'] = {}b['x']['x'] = bprint eq(a, b) # True

上面代码中, id() 用来取得一个对象的唯一id(原始类型的int, string等, 引用类型的dict, list object都可以使用), 可以理解为c语言中的指针的角色.

效率分析

假设 a , b 的节点数分别是m和n, 那么, 因为整个遍历过程最多经一个 节点对 一次, 并且最多也需要记录所有的 节点对 的被访问的历史, 在上面的递归实现中, 最差情况是遇到一个经过了所有 节点对 的环, 因此: