2 binäre Bäume gleich sind oder nicht

Gleichheitsoperatoren sind transitiv: Wenn A = B und B = C, dann A = B = C, so A = C.

Gleichheitsoperatoren sind reflexiv: A = A, B = B, und C = C egal, was ihre Werte sind.

Gleichheitsoperatoren sind symmetrisch. Wenn A = B, dann B = A. (Es ist egal, in welcher Reihenfolge sie sind in.)

Nun, ein Blick auf die Definition sie dir gegeben habe:

Ein Baum ist zu einem anderen Baum gleich, wenn die Kinder gleich sind. Mal schauen. Wir können davon ausgehen, dass die Knoten am Boden verglichen werden, oder aber die Definition ist ziemlich nutzlos. Aber sie kümmern sich nicht darum, Ihnen zu sagen, wie man diesen Vergleich zu lösen, und die ganze Definition sie Sie gaben Scharniere darauf.

Kurz gesagt, ist es eine beschissene Frage.

Mal sehen, was passiert, wenn wir uns entscheiden, die Frage versuchen wollen und zu entwirren, though.

Aber warten Sie , sie Ihnen auch sagen , dass die beiden Kinder jeden Baum getauscht werden kann. Dadurch wird die Einschränkung , dass jeder Baum, der auf etwas anderes (einschließlich sich selbst) gleich ist , muss auf sein Spiegelbild gleich sein. Und alle Variationen seiner Unterbäume Kinder getauscht werden.

Und denken Sie daran , dass es sich hierbei um eine sein Suchbaum. Deshalb können wir wohl davon ausgehen , dass zwei verschiedene Suchbäume , die durch den gleichen Algorithmus verarbeitet werden , müssen das gleiche Ergebnis , wenn sie gleich sind. Also, wenn wir um die Elemente eines Baumes zu wechseln, dann würde die Suchzeit beeinflusst werden. Also, Bäume, die einander nicht jeden Knoten an der richtigen Stelle sind nicht gleich.

dass zusammen mit der „Swap“ Eigenschaft dieser Gleichheit Einlochen, können wir es keine gültige Definition der Gleichheit sehen. (Wenn wir versuchen, es anzuwenden, dann stellt sich heraus, dass nur Bäume, die den gleichen Knoten für jeden Knoten auf einer bestimmten Ebene haben gleich sind, und nur auf sich selbst, die die Reflexivität Teil eines Gleichheitsoperator bricht.)

Wenn Sie ihre Definition von „Gleichheit“ mit Flip-Invarianz implementieren, werden Sie die Definition der Gleichheit verstoßen. Die Definition ist auch nicht sinnvoll, denn das ist nicht, wie binäre Suchbäume gleich sind (es sei denn jeder Knoten einen Zeiger aufweist, an dem Teilbaum „größer“ ist und was „weniger“).

Sie haben zwei Möglichkeiten der angemessenen Definitionen:

1. topologischen (Flip-Agnostiker) Äquivalenz (in diesem Fall können Sie nicht nennt es einen „binärer Suchbaum“ , weil es nicht sortiert ist):

   tree1==tree2 meint set(tree1.children)==set(tree2.children)

2. normaler Suchbaum (Flip-fürsorgliche) Äquivalenz:

   tree1==tree2 meint list(tree1.children)==list(tree2.children)

Für binäre Bäume, werden die obigen Definitionen arbeiten als schriftliche in jeder Sprache , der die Träger listund setDatentypen (Python - Sets werden Drossel jedoch auf unhashable Datentypen). Dennoch unten sind einige ausführlichere und hässlich C / Java-ähnliche Definitionen:

1. topologische Äquivalenz:

   t1==t2 meint (t1.left==t2.left and t1.right==t2.right) or (t1.left==t2.right and t1.right==t2.left)

2. sortierten Baum Äquivalenz:

   t1==t2 meint (t1.left==t2.left and t1.right==t2.right)

Die obigen Definitionen sind rekursiv; das heißt, übernehmen sie die Gleichstellung der für die Teilbäume und basen Fällen bereits definiert, die es hat.

Randnotiz:

Zitat: tree1-> Kind == tree2-> Kind

Dies ist keine gültige Aussage, weil ein Baumknoten kein einziges Kind hat.

Ich las die Fragen wie: zwei binäre Bäume gegeben, für jede Tiefe in dem Baum, herauszufinden, ob ihre Kinder Satz ist in ihnen abgedeckt.

Dies kann relativ einfach codiert werden.

Lösung ohne Rekursion in Ruby

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

Ruby-Syntax Tipps:

• (1) setzen Element in Array: arr << elem; in diesem Fall for_checkist Array von Arrays
• (2) parallel Zuordnung: t1,t2 = [item1, item2]. Gleich wiearr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrenangenommen entsprechendes Verhalten von == für diese Art von Objekten. Ausführlicher sein wird t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- hier mapproduziert von vals Array.

Vergleichen Bäume mit Heiligsprechung Ansatz vorgeschlagen @mcdowella . Der Unterschied ist , dass mein Ansatz nicht erfordert O(N)zusätzliche Speicher WRT Anzahl der Knoten im Baum:

# 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()erfordert O(N*M)Schritte und O(log(N)*M)Speicher , alle Knoten in einem Baum zu erhalten, in denen NGesamtanzahl von Knoten ist, MAnzahl der Kinder jeder Knoten hat (es ist 2 für binäre Bäume).

canonorder()könnte für jede Knotendarstellung und eine beliebige Anzahl von Kindern leicht verallgemeinert. canonwalk()nur verlangt , dass ein Baum seiner unmittelbaren Kinder als Folge zugreifen kann.

Die Vergleichsfunktion, die ruft 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

Beispiel

    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)

Ausgabe

True