2 arbori binari sunt egale sau nu

Operatorii sunt tranzitive de egalitate: Dacă A = B și B = C, atunci A = B = C deci A = C.

Operatorii de egalitate sunt reflexive: A = A, B = B, și C = C, indiferent de valorile lor sunt.

Operatorii de egalitate sunt simetrice. Dacă A = B, atunci B = A. (Nu contează ce ordine acestea sunt.)

Acum, luând o privire la definiția ți-au dat:

Un copac este egal cu un alt copac în cazul în care copiii sunt egali. Sa vedem. Putem presupune că nodurile sunt comparate în partea de jos, sau altfel definiția este destul de inutil. Dar ei nu deranjează să-ți spun cum să rezolve această comparație, și întreaga definiție ți-au dat depinde de ea.

Pe scurt, este o chestiune de doi bani.

Să vedem ce se întâmplă dacă decidem vrem să încercăm să dezlege problema, totuși.

Dar stai, ei vă spun , de asemenea , că cei doi copii de orice copac pot fi schimbate. Aceasta adaugă constrângerea că orice pom , care este egal cu orice altceva (inclusiv în sine) trebuie să fie egală cu imaginea sa în oglindă. Și orice variații ale copiilor subarbori săi fiind schimbate.

Și amintiți - vă că acest lucru ar trebui să fie o căutare copac. Prin urmare, putem presupune , probabil , că doi arbori de căutare diferite care sunt procesate de același algoritm trebuie să dea același rezultat , dacă acestea sunt egale. Deci, dacă vom trece în jurul valorii de elementele unui copac, atunci timpul de căutare va fi afectată. Deci, copacii care nu au fiecare nod în loc nu sunt egale între ele.

Punerea că, împreună cu proprietatea „swappable“ a acestei egalitati, putem vedea că nu este o definiție validă a egalității. (Dacă vom încerca să-l aplice, atunci se dovedește că numai copacii care au același nod pentru fiecare nod la un anumit nivel sunt egale, și numai pentru ei înșiși, care rupe partea reflexivitate a unui operator de egalitate.)

Dacă implementați definiția lor de „egalitate“ cu flip-invarianta, vă va încălca definiția egalității. Definiția nu are nici un sens, pentru că nu este modul în care copacii de căutare binare sunt egale (cu excepția cazului în fiecare nod are un pointer la care subarborele este „mai mare“ și care este „mai mic“).

Ai două variante de definiții rezonabile:

1. topologic (flip-agnostic) echivalență (caz în care nu se poate numi un „arbore binar de căutare“ , deoarece nu este sortate):

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

2. căutare arbore normal (flip-îngrijire) echivalență:

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

Pentru arbori binari, definițiile de mai sus vor lucra ca scrise în orice limbă , care sprijină listși settipuri de date (seturi de piton va sufoca însă pe tipuri de date unhashable). Cu toate acestea, mai jos sunt câteva definiții C / Java , cum ar fi mai logoreic și urât:

1. echivalență topologic:

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

2. sortat echivalență copac:

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

Definițiile de mai sus sunt recursive; adică, ei presupun egalitate a fost definit pentru subramificații și de baze de cazuri deja, pe care le are.

notă marginală:

Citat: tree1-> copil == tree2-> copil

Aceasta nu este o afirmație valabilă, pentru că un nod copac nu are un singur copil.

Am citit întrebările ca: dat doi arbori binari, pentru fiecare adâncime în copac, pentru a afla dacă setul de copii lor sunt acoperite unul în celălalt.

Acest lucru poate fi codificate relativ ușor.

Soluție fără recursivitate în 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 sfaturi de sintaxă:

• (1) punerea elementului în matrice: arr << elem; în acest caz for_checkeste matrice de matrice
• (2) Atribuirea paralelă: t1,t2 = [item1, item2]. La fel caarr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrenpresupus comportament corespunzător de == pentru acest tip de obiecte. Mai multe verbose va fi t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- aici mapproduce matrice de Vals.

Compara copaci folosind abordarea sugerată de canonizare @mcdowella . Diferența este că abordarea mea nu are nevoie de O(N)memorie suplimentară numărul WRT de noduri din arbore:

# 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()necesită O(N*M)pași și O(log(N)*M)memorie pentru a produce toate nodurile dintr - un copac, unde Neste numărul total de noduri, Mnumărul de copii fiecare nod are (este 2 pentru arbori binari).

canonorder()ar putea fi ușor generalizată pentru orice reprezentare nod și orice număr de copii. canonwalk()necesită doar ca un copac poate avea acces la copiii săi imediați ca secvență.

Funcția de comparație solicită 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

Exemplu

    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)

producție

True