2 binaire bomen gelijk of niet

Gelijkheid operators transitieve: Als A = B en B = C, dan A = B = C zodat A = C.

Gelijkheid operators zijn reflexieve: A = A, B = B, en C = C, ongeacht wat hun waarden zijn.

Gelijkheid operators zijn symmetrisch. Indien A = B en B = A. (Het maakt niet uit welke volgorde ze zich bevinden.)

Nu, met een blik op de definitie gaven ze je:

Een boom is gelijk aan een andere boom als de kinderen gelijk zijn. Laten we eens kijken. We kunnen aannemen dat de knooppunten worden vergeleken aan de onderkant, of anders de definitie is vrij nutteloos. Maar ze niet de moeite om je te vertellen hoe je die vergelijking op te lossen, en de hele definitie gaven ze je hangt af van het.

Kortom, het is een waardeloze vraag.

Laten we eens kijken wat er gebeurt als we besluiten dat we willen proberen en het ontrafelen van de vraag, dat wel.

Maar wacht, ze je ook vertellen dat de twee kinderen van elke boom kan worden verwisseld. Dit voegt de beperking dat elke boom die gelijk is aan iets anders (inclusief zichzelf) gelijk zijn spiegelbeeld te moeten zijn. En alle variaties van de kinderen haar substructuren worden verwisseld.

En vergeet niet dat dit wordt verondersteld te zijn een zoekactie boom. Daarom kunnen we waarschijnlijk aannemen dat twee verschillende search bomen die worden verwerkt door dezelfde algoritme moet hetzelfde resultaat geven als ze gelijk zijn. Dus, als we overschakelen rond de elementen van een boom, dan is de zoektijd zou worden beïnvloed. Dus, bomen die niet elk knooppunt hebben op zijn plaats zijn niet aan elkaar gelijk.

Putting die samen met de "swap" eigenschap van deze gelijkheid, kunnen we zien dat het geen geldige definitie van gelijkheid. (Als we proberen om het toe te passen, dan blijkt dat alleen bomen die hetzelfde knooppunt voor elk knooppunt hebben op een bepaald niveau gelijk zijn, en alleen voor zichzelf, waardoor de reflexiviteit onderdeel van een operator gelijkheid breekt.)

Als je hun definitie van "gelijkheid" met flip-invariantie te voeren, vindt u de definitie van gelijkheid te schenden. De definitie niet eens zin te maken, want dat is niet hoe binary search bomen gelijk zijn (tenzij elk knooppunt heeft een pointer naar die deelboom "groter" en dat is "mindere").

Je hebt twee keuzes van redelijke definities:

1. topologische (flip-agnostisch) gelijkwaardigheid (in dat geval kun je het niet noemen het een "binary search tree" omdat het niet gesorteerd):

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

2. normaal zoekboom (flip-verzorgende) gelijkwaardigheid:

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

Binaire bomen, zal bovenstaande definities werken als geschreven in een taal die het ondersteunt listen setdatatypes (python sets echter stikken unhashable datatypes). Niettemin, hieronder zijn wat meer uitgebreide en lelijk C / Java-achtige definities:

1. topologische equivalentie:

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

2. gesorteerde boom gelijkwaardigheid:

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

De bovenstaande definities recursief; dat wil zeggen, zij veronderstellen gelijkheid gedefinieerd voor de deelbomen en basis-gevallen al, waarin zij.

kanttekening:

citaat: tree1-> kind == tree2-> kind

Dit is geen geldige verklaring, omdat een boom knooppunt één kind heeft.

Ik lees de vragen als: gegeven twee binaire bomen, voor elke diepte in de boom, erachter te komen of set van hun kinderen worden behandeld in elkaar.

Dit kan worden gecodeerd relatief eenvoudig.

Oplossing zonder recursie 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 tips:

• (1) brengen element in array: arr << elem; In dit geval for_checkwordt matrix van matrices
• (2) parallel werkstuk: t1,t2 = [item1, item2]. Hetzelfde alsarr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrenveronderstelde overeenkomstige gedrag == voor dit soort voorwerpen. Meer breedsprakig zal zijn t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- hier mapproduceert serie van vals.

Vergelijk bomen met behulp van heiligverklaring aanpak door gesuggereerd @mcdowella . Het verschil is dat mijn aanpak niet nodig O(N)extra geheugen mbt aantal knooppunten in de boom:

# 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()vereist O(N*M)stappen en O(log(N)*M)geheugen om alle knooppunten op in een boom, waarbij Nis totale aantal knooppunten, Maantal kinderen ieder knooppunt (het 2 binaire bomen).

canonorder()kan gemakkelijk worden gegeneraliseerd voor knooppunt representatie en elk aantal kinderen. canonwalk()vereist slechts dat een boom als een opeenvolging hebt toegang tot de directe kinderen.

De vergelijking functie die roept 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

Voorbeeld

    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)

uitgang

True