2 arbres binaires sont égaux ou non

opérateurs d'égalité sont transitif: Si A = B et B = C, alors A = B = C alors A = C.

opérateurs d'égalité sont réflexif: A = A, B = B et C = C quelles que soient leurs valeurs.

opérateurs d'égalité sont symétriques. Si A = B, alors B = A. (Peu importe quel ordre ils sont.)

Maintenant, jeter un oeil à la définition qu'ils vous ont donné:

Un arbre est égal à un autre arbre, si les enfants sont égaux. Voyons voir. On peut supposer que les noeuds sont comparés au fond, ou bien la définition est assez inutile. Mais ils ne prennent pas la peine de vous dire comment résoudre cette comparaison, et la définition entière, ils vous ont donné des charnières dessus.

En bref, il est une question merdique.

Voyons voir ce qui se passe si nous décidons que nous voulons essayer de démêler la question, cependant.

Mais attendez, ils vous disent aussi que les deux enfants de tout arbre peuvent être permutés. Cela ajoute la contrainte que tout arbre qui est égal à rien d' autre (y compris lui - même) doit être égale à son image miroir. Et étant permutés les variations des enfants de ses sous - arbres.

Et rappelez - vous que cela est censé être une recherche arbre. Par conséquent, on peut sans doute supposer que deux qui sont des arbres de recherche différents traités par le même algorithme doit donner le même résultat si elles sont égales. Donc, si on passe autour des éléments d'un arbre, le temps de recherche serait affectée. Ainsi, les arbres qui ne sont pas tous les nœuds en place ne sont pas égaux entre eux.

Mettre qui, ensemble, avec la propriété « swappable » de cette égalité, nous pouvons voir ce n'est pas une définition valable de l'égalité. (Si nous essayons de l'appliquer, il se révèle que seuls les arbres qui ont le même noeud pour chaque noeud à un niveau particulier sont égaux, et seulement à eux-mêmes, qui brise la partie réflexivité d'un opérateur d'égalité).

Si vous implémentez la définition d ' « égalité » avec flip-invariance, vous violer la définition de l'égalité. La définition ne fait même pas de sens, car ce n'est pas comment les arbres binaires de recherche sont égaux (à moins que chaque nœud a un pointeur auquel est sous-arbre « plus » et qui est « moins »).

Vous avez deux choix de définitions raisonnables:

1. topologique équivalence (agnostique FLIP) (dans ce cas , vous ne pouvez pas l' appeler un « arbre de recherche binaire » , car il n'est pas triée):

   tree1==tree2 veux dire set(tree1.children)==set(tree2.children)

2. arbre de recherche normale (flip-soins) équivalence:

   tree1==tree2 veux dire list(tree1.children)==list(tree2.children)

Pour les arbres binaires, les définitions ci - dessus fonctionnent comme écrit dans une langue qui prend en charge le listet les settypes de données (jeux de python étoufferont cependant sur les types de données unhashable). Néanmoins, voici quelques plus verbeux et laids C / définitions de type Java:

1. équivalence topologique:

   t1==t2 veux dire (t1.left==t2.left and t1.right==t2.right) or (t1.left==t2.right and t1.right==t2.left)

2. équivalence arbre Sorted:

   t1==t2 veux dire (t1.left==t2.left and t1.right==t2.right)

Les définitions ci-dessus sont récursifs; à savoir, ils supposent l'égalité a été définie pour les sous-arbres et de base-cas déjà, qu'il a.

sidenote:

citation: tree1-> enfant == tree2-> enfant

Ce n'est pas une déclaration valide, parce qu'un nœud d'arborescence ne dispose pas d'un seul enfant.

Je lis les questions suivantes: étant donné deux arbres binaires, pour chaque profondeur dans l'arbre, savoir si l'ensemble de leurs enfants sont couverts dans l'autre.

Cela peut être codé relativement facile.

Solution sans récursivité en 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 conseils de syntaxe:

• (1) élément de mise en réseau: arr << elem; dans ce cas , for_checkest un tableau de tableaux
• (2) attribution parallèle: t1,t2 = [item1, item2]. Pareil quearr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrensuppose un comportement correspondant de == pour ce genre d'objets. Plus bavard sera être t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- ici mapproduit tableau de vals.

Comparer les arbres à l' aide approche Canonisation suggérée par @mcdowella . La différence est que mon approche ne nécessite pas le O(N)numéro de WRT mémoire supplémentaire de nœuds dans l'arborescence:

# 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()nécessite des O(N*M)étapes et la O(log(N)*M)mémoire pour donner tous les noeuds dans un arbre, où Nest le nombre total de noeuds, le Mnombre d'enfants chaque noeud a (il est 2 pour les arbres binaires).

canonorder()pourrait facilement être généralisé pour toute représentation de noeud et un certain nombre d'enfants. canonwalk()exige seulement qu'un arbre peut accéder à ses enfants immédiats comme une séquence.

La fonction de comparaison qui appelle 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

Exemple

    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)

Sortie

True