2 бинарных деревьев, равны или нет

Операторы равенства транзитивны: Если А = В и В = С, то А = В = С, так A = C.

Операторы равенства не рефлексивно: A = A, B = B, и C = C, независимо от того, каковы их ценности.

Операторы равенства симметричны. Если A = B, то В = A. (Это не имеет значения, в каком порядке они находятся.)

Теперь, принимая взглянуть на определение они дали вам:

Дерево равно другое дерево, если дети равны. Посмотрим. Можно предположить, что узлы сравниваются на дне, или же определение довольно бесполезно. Но они не удосужились сказать вам, как решить, что сравнение, и в целом определение они дали вам зависит от него.

Короче говоря, это дерьмовый вопрос.

Давайте посмотрим, что произойдет, если мы решим, что мы хотим, чтобы попытаться разгадать этот вопрос, хотя.

Но подождите, они также говорят, что двое детей любого дерева можно поменять местами. Это добавляет ограничение , что любое дерево , которое равно все остальное ( в том числе и себя) должно быть равно его зеркальным отражение. И любые вариации детей его поддеревьев могли быть обменены.

И помните , что это должно быть поиск дерево. Таким образом, мы можем предположить , что два различных дерева поиска, которые обрабатываются с помощью того же алгоритма должны дать тот же результат , если они равны. Таким образом, если мы переключаемся вокруг элементов дерева, то время поиска будет затронуто. Таким образом, деревья , которые не имеют каждый узел в месте, не равны друг другу.

Полагая, что вместе с «съемном» свойством этого равенства, мы можем видеть, что это не является допустимым определением равенства. (Если мы попытаемся применить его, то получается, что только деревья, которые имеют один и тот же узел для каждого узла на определенном уровне, равны, и только для себя, который ломает рефлексивности часть оператора равенства.)

Если вы реализуете свое определение «равенства» с флип-инвариантности, вы будете нарушать определение равенства. Определение даже не имеет смысла, потому что это не так, как бинарные деревья поиска, равны (если каждый узел не имеет указатель на который поддерево «больше» и что «меньшее»).

У вас есть два варианта разумных определений:

1. топологический (флип-агностик) эквивалентности (в этом случае вы не можете назвать это «бинарное дерево» , потому что это не отсортирован):

   tree1==tree2 означает set(tree1.children)==set(tree2.children)

2. нормальное дерево поиска (флип-заботливый) эквивалентность:

   tree1==tree2 означает list(tree1.children)==list(tree2.children)

Для бинарных деревьев, приведенные выше определения будут работать как написаны на любом языке , который поддерживает listи setтипы данных (наборы Python будет заглушают однако на unhashable типов данных). Тем не менее, ниже приведены некоторые более многословные и уродливые / Java-подобные определения C:

1. топологической эквивалентности:

   t1==t2 означает (t1.left==t2.left and t1.right==t2.right) or (t1.left==t2.right and t1.right==t2.left)

2. отсортированный дерево эквивалентности:

   t1==t2 означает (t1.left==t2.left and t1.right==t2.right)

Определения выше, являются рекурсивными; то есть, они предполагают равенство было определено для поддеревьев и базовых случаях уже, что он имеет.

Примечание:

цитата: tree1-> ребенок == tree2-> ребенок

Это не является правильным утверждение, так как узел дерева не имеет ни одного ребенка.

Я прочитал вопросы, как: даны два бинарных деревьев, для каждой глубины в дереве, выяснить, является ли покрыты их детский набор друг в друге.

Это может быть закодировано относительно легко.

Решение без рекурсии в Рубине

def same? top_t1, top_t2
  for_chek << [top_t1, top_t2]   # (1) put task for check into queue

  while t1,t2 = for_check.shift  # (2)
    return false unless t1.children.count == t2.children.count  # generally for non-binary tree, but also needed for controlling of nil children
    break if t1.children.empty?

    t1_children = t1.children.sort # this is sorted arrays
    t2_children = t2.children.sort # of childrens      
    return false unless t1_children == t2_children  # (3)

    0.upto(t1_children.count - 1) do |i|
      for_check << [t1_children[i], t2_children[i]]  # put equivalent child pairs into queue
    end
  end
  return true
end

Рубиновые советы синтаксис:

• (1) положить элемент в массив: arr << elem; в этом случае for_checkявляется массивом массивов
• (2) параллельное назначение: t1,t2 = [item1, item2]. Такой же какarr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrenпредполагается соответствующее поведение == для такого рода объектов. Подробней будет t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- здесь mapпроизводит множество вальса.

Сравнение деревьев , используя канонизации подход , предложенный @mcdowella . Разница заключается в том, что мой подход не требует O(N)дополнительной памяти WRT количество узлов в дереве:

# in Python
from collections import namedtuple
from itertools import chain

# Tree is either None or a tuple of its value and left, right trees
Tree = namedtuple('Tree', 'value left right')

def canonorder(a, b):
    """Sort nodes a, b by their values.

    `None` goes to the left
    """
    if (a and b and a.value > b.value) or b is None:
        a, b = b, a # swap
    return a, b

def canonwalk(tree, canonorder=canonorder):
    """Yield all tree nodes in a canonical order.

    Bottom-up, smaller children first, None is the smallest
    """
    if tree is not None:
        children = tree[1:]
        if all(t is None for t in children): return # cut None leaves
        children = canonorder(*children)            
        for child in chain(*map(canonwalk, children)):
            yield child
    yield tree 

canonwalk()требует O(N*M)шагов и O(log(N)*M)памяти , чтобы получить все узлы в дереве, где Nэто общее число узлов, Mчисло детей , каждый узел имеет (это 2 для бинарных деревьев).

canonorder()может быть легко обобщена для любого представления узлов и любое количество детей. canonwalk()требует только то , что дерево может получить доступ к его непосредственным потомкам в виде последовательности.

Функция сравнения , которая требует canonwalk():

from itertools import imap, izip_longest

unset = object() 
def cmptree(*trees):
    unequal = False # allow root nodes to be unequal
    # traverse in parallel all trees under comparison
    for nodes in izip_longest(*imap(canonwalk, trees), fillvalue=unset):
        if unequal:
            return False # children nodes are not equal
        if any(t is unset for t in nodes):
            return False # different number of nodes
        if all(t is not None for t in nodes):
            unequal = any(nodes[-1].value != t.value for t in nodes)
        else: # some are None
            unequal = any(t is not None for t in nodes)
    return True # equal

пример

    5         6
   / \       / \           they are equal.
  1   2     2   1
 /     \   /    / 
3       4 4     3

tree1 = Tree(5, 
             Tree(1, 
                  Tree(3, None,None), None), 
             Tree(2, 
                  None, Tree(4, None, None)))
tree2 = Tree(6, 
             Tree(2, Tree(4, None, None), None),
             Tree(1, Tree(3, None, None), None))
print cmptree(tree1, tree2)

Вывод

True