2 ikili ağaçlar eşit ya da

Eşitlik operatörleri geçişli gibidir: Eğer, A = B = C, A = C böylece A = B ve B = C,.

Eşitlik operatörleri dönüşlü şunlardır: A = A, B = B ve C = C olursa olsun değerlerin ne.

Eşitlik operatörleri simetriktir. bu durumda B = A = B, ise. (Onların içinde ne sırası önemli değildir.)

Şimdi, onlar size verdiği tanım bir göz alarak:

Çocukların eşitse bir ağaç başka ağaç eşittir. Bakalım. Biz düğümleri altta karşılaştırıldığında, ya da başka tanımı oldukça işe yaramaz ediliyor varsayabiliriz. Ama bu nasıl karşılaştırma çözmek için söylemek zahmet etmeyin, onlar size verdiği bütün tanım buna bağlı.

Kısacası, berbat bir soru.

en rağmen biz soruyu denemek ve çözülmeye istediğinize karar ne olur görelim.

Ama bekleyin, onlar da herhangi ağacın iki çocuk takas olabilir söyleyecektir. Bu kısıtlamayı ekleyen herhangi (kendisi de dahil) başka bir şey eşittir ağaç, ayna görüntüsü eşit olmalıdır. Ve onun alt ağaç çocukların herhangi bir varyasyon takas olma.

Ve bu bir olması gerekiyordu unutmayın arama ağacı. Bu nedenle, muhtemelen aynı algoritma tarafından işlenir iki farklı arama ağaçları varsayabiliriz gerekir eşit iseler aynı sonucu verir. Biz bir ağacın unsurları etrafında geçiş yüzden, eğer daha sonra arama süresi etkilenecektir. Yani, mekandaki tüm düğüm yok ağaçlar birbirine eşit değildir.

Bu eşitlik "değiştirilebilen" özelliği ile bir araya koyarak, bunu eşitlik geçerli bir tanım değil görebilirsiniz. (Biz bunu uygulamak çalışırsanız, o zaman belli bir düzeyde her düğüm için aynı düğüme sahip sadece ağaçlar bir eşitlik operatörünün dönüşlülük kısmını kırar hangi ve sadece kendilerine, eşit olduğu ortaya çıktı.)

Eğer flip-değişmezliği ile "eşitlik" tanımını uygularsanız, eşitlik tanımı ihlal edecektir. (her bir düğüm bir işaretçiyle olmadıkça alt ağaç "daha büyük" ve "daha az" olduğu için) ikili arama ağaçları eşit değil nasıl için tanımlama bile, mantıklı değildir.

Makul tanımlardan iki seçenek vardır:

1. topolojik (flip-agnostik) denklik (o sıralanmış değil çünkü bu durumda bir "ikili arama ağacı" adını olamaz):

   tree1==tree2 anlamına geliyor set(tree1.children)==set(tree2.children)

2. Normal arama ağacı (flip-sevecen) eşdeğerlik:

   tree1==tree2 anlamına geliyor list(tree1.children)==list(tree2.children)

İkili ağaçların, yukarıda tanımları destekleyen herhangi bir dilde olduğu gibi yazılmış çalışacak listve set(piton setleri unhashable veri tipleri hakkında ancak şok edecek) veri tipleri. Bununla birlikte, aşağıda biraz daha ayrıntılı ve çirkin C / Java benzeri tanımlamalar şunlardır:

1. topolojik denklik:

   t1==t2 anlamına geliyor (t1.left==t2.left and t1.right==t2.right) or (t1.left==t2.right and t1.right==t2.left)

2. sıralı ağaç eşdeğerlik:

   t1==t2 anlamına geliyor (t1.left==t2.left and t1.right==t2.right)

tanımları, yukarıda tekrar eder; yani onlar eşitlik sahip olduğu zaten alt ağaçlar ve baz durumlarda, için tanımlanmış varsayalım.

kenar notu:

alıntı: tree1-> çocuk == tree2-> çocuk

Bir ağaç düğümü tek çocuğu olmadığı için bu geçerli bir ifade değil.

ağaçtaki her derinliği, çocuklarının seti birbirlerinin kaplıdır olmadığını öğrenmek, iki ikili ağaçlar verilen: Ben gibi sorular okuyun.

Bu nispeten kolay kodlanabilir.

Ruby özyineleme olmadan Çözüm

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

Yakut sözdizimi ipuçları:

• (1) diziye elemanının koyarak: arr << elem; Bu durumda, for_checkdizilerin dizidir
• (2) paralel bir tahsisi: t1,t2 = [item1, item2]. İle aynıarr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrennesneler için bu tür == karşılık gelen davranış üstlendi. Daha ayrıntılı olacak t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- burada mapvals dizisini üretir.

Önerdiği canonization yaklaşımı kullanarak ağaçları karşılaştırın @mcdowella . Fark yaklaşımım gerektirmez olmasıdır O(N)ağaçta düğümlerin ek bellek wrt numarasını:

# 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()gerektirir O(N*M)adımlar ve O(log(N)*M)bir ağaç, tüm düğümlerin vermek üzere bellek Ndüğümlerinin toplam sayısını, Mher bir düğüm, çocuk (ikili ağaçlar 2) sayısı.

canonorder()kolayca herhangi düğüm temsil ve çocukların herhangi bir sayı için genelleştirilmiş edilebilir. canonwalk()Bir ağaç bir dizi olarak onun hemen çocuk erişebilir sadece gerektirir.

Çağıran karşılaştırma fonksiyonu 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

Örnek

    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)

Çıktı

True