SICP_Python版第二章:集合的表示

构造最简单也最低效的集合表示法

def first(x):return x[0]
def rest(x):return x[1:]
def element_of(x,s):
    if len(s)==0:return False
    elif x==first(s):return True
    return element_of(x,rest(s))
def adjoinset(x,s):
    if element_of(x,s):return s
    return (x,)+s
def intersection(s1,s2):
    if len(s1)+len(s2)==0:return ()
    if element_of(first(s1),s2):
        return (first(s1),)+intersection(rest(s1),s2)
    else:return intersection(rest(s1),s2)
def union_set(s1,s2):
    if len(s1)==0:return s2
    if len(s2)==0: return s1
    if not element_of(first(s1),s2):
        return (first(s1),)+union_set(rest(s1),s2)
    return union_set(rest(s1),s2)
def make_set(s):
    final_set = ()
    for each in s:
        final_set=adjoinset(each,final_set)
    return final_set

$2.61-2.62$构造集合是升序排列的,这样可以对元素各个集合操作进行加速。合并和交集改进为O(n)

def rest(x):return x[1:]
def element_of(x,s):
    if len(s)==0:return False
    elif x==first(s):return True
    elif x < first(s):return False
    return element_of(x,rest(s))
def adjoinset(x,s):
    if len(s)==0:return (x,)
    if x==first(s):return s
    elif x>first(s):return (first(s),)+adjoinset(x,rest(s))
    else:return (x,)+s
def intersection(s1,s2):
    if len(s1)==0 or len(s2)==0:return ()
    if first(s1)==first(s2):
        return (first(s1),)+intersection(rest(s1),rest(s2))
    elif first(s1)<first(s2):
        return intersection(rest(s1),s2)
    return intersection(s1,rest(s2))
def union_set(s1,s2):
    if len(s1)==0:return s2
    if len(s2)==0: return s1
    if first(s1)==first(s2):
        return (first(s1),)+union_set(rest(s1),rest(s2))
    elif first(s1)<first(s2):
        return (first(s1),)+union_set(rest(s1),s2)
    return union_set(s1,rest(s2))
def make_set(s):
    final_set = ()
    for each in s:
        final_set=adjoinset(each,final_set)
    return final_set

$将集合表示为二叉树$

ef entry(tree):return tree[0]
def left_tree(tree):return tree[1]
def right_tree(tree):return tree[2]
def make_tree(data,left=None,right=None):return [data,left,right]
def element_of(x,s):
    if s==None:return False
    if x==entry(s):return True
    elif x<entry(s):return element_of(x,left_tree(s))
    else:return element_of(x,right_tree(s))
def add_node(x,t):
    if t==None: t = make_tree(x)
    elif x<entry(t):t[1] = add_node(x,left_tree(t))
    else:t[2] = add_node(x,right_tree(t))
    return t

$2.63(a)$都是中序遍历的结果。

$(b)$:复杂度是不一样的,前者是O(nlogn)的复杂度,后者是O(N).

$$T(N) = 2T(N/2)+O(N)$$
$$T(N) = 2T(N/2)+O(1)$$

$2.64$

$T(N) = O(N)$

def list_to_tree(sets):
    def sub(x):
        if x<0:return ()
        return sets[0:x]
    n = len(sets)
    leftsize = (n-1)>>1
    if n == 0:return None
    first = sets[leftsize]
    left_tree = list_to_tree(sub(leftsize))
    right_tree = list_to_tree(sets[leftsize+1:])
    return make_tree(first,left_tree,right_tree)
print(list_to_tree((1,2,3,4,5,6,7)))

$2.65$只是示范一下Union_set。

注意,已开始我尝试直接递归求解,但是虽然求出来了，但不是O(N)的复杂度,这里也给出一个提示:$当树状的结构确实不好处理，可以考虑转换为有序表。$

def tree_union_set(s1,s2):
    x,y = tree_to_list(s1),tree_to_list(s2)
    u = union_set(tuple(x),tuple(y))
    return list_to_tree(u)
def tree_to_list(s):
    ans = []
    def add(x):
        if x==None:return
        add(left_tree(x));ans.append(entry(x));add(right_tree(x))
    add(s)
    return ans