2 द्विआधारी पेड़ के बराबर हैं या नहीं

समानता ऑपरेटरों सकर्मक हैं: अगर एक = बी, और B = C, तो एक = B = C तो एक = सी।

, कोई बात नहीं क्या उनके मूल्यों रहे हैं एक = एक बी = बी, और सी = C: समानता ऑपरेटरों कर्मकर्त्ता हैं।

समानता ऑपरेटरों सममित होते हैं। एक = बी, तो बी = एक है। (इससे कोई फर्क नहीं पड़ता कि जिस क्रम में वे कर रहे हैं।)

अब, परिभाषा वे तुम्हें दे दी है पर एक नज़र डालने:

अगर बच्चों के बराबर हैं एक पेड़ एक और पेड़ के बराबर है। चलो देखते हैं। हम चाहते हैं कि नोड्स तल पर की तुलना में किया जा रहा है, वरना परिभाषा बहुत बेकार है यह मान सकते हैं। लेकिन वे आपको बता कैसे कि तुलना को हल करने के लिए परेशान नहीं है, और पूरी परिभाषा वे तुम्हें दे दी है उस पर टिका है।

संक्षेप में, यह एक भद्दा सवाल है।

चलो देखते हैं अगर हम तय हम कोशिश करते हैं और प्रश्न को जानने के लिए चाहते हैं कि क्या होता है, हालांकि।

लेकिन रुकिए, वे भी आपको बता दूँ कि किसी भी पेड़ के दो बच्चों की अदला-बदली जा सकती है। इस बाधा है कि कहते हैं किसी भी पेड़ है कि और (अपने आप सहित) कुछ भी करने के बराबर है अपने दर्पण छवि के बराबर होना चाहिए। और इसकी subtrees 'बच्चों की किसी भी विविधता बदली जा रहा है।

और याद रखें कि यह एक माना जाता है खोज पेड़। इसलिए, हम शायद मान सकते हैं कि दो अलग अलग खोज के पेड़ है कि एक ही एल्गोरिथ्म द्वारा कार्रवाई की जाती है चाहिए एक ही परिणाम अगर वे बराबर हैं दे। तो, अगर हम एक पेड़ के तत्वों के चारों ओर चले जाते हैं, तो खोज समय प्रभावित होंगे। तो, पेड़ उस जगह में प्रत्येक नोड की जरूरत नहीं है एक दूसरे के बराबर नहीं हैं।

इस समानता के "स्वैप" संपत्ति के साथ कि एक साथ लाना है, हम इसे समानता का एक मान्य परिभाषा नहीं है देख सकते हैं। (हम इसे लागू करने का प्रयास है, तो यह पता चला है कि केवल पेड़ एक विशेष स्तर पर प्रत्येक नोड के लिए एक ही नोड है कि बराबर हैं, और केवल खुद को, जो एक समानता ऑपरेटर के रिफ्लेक्सिविटी हिस्सा टूट जाता है।)

आप फ्लिप निश्चरता के साथ "समानता" की अपनी परिभाषा को लागू हैं, तो आप समानता की परिभाषा का उल्लंघन होगा। परिभाषा भी, मतलब नहीं है क्योंकि (जब तक प्रत्येक नोड एक सूचक है जो करने के लिए सबट्री "अधिक" है और जो "कम" है) कैसे नहीं द्विआधारी खोज के पेड़ के बराबर हैं कि।

आप उचित परिभाषा के दो विकल्प हैं:

1. संस्थानिक (फ्लिप-नास्तिक) तुल्यता (इस स्थिति में आप इसे एक "बाइनरी खोज पेड़" फोन नहीं कर सकते हैं क्योंकि यह पृथक नहीं किया जा रहा है):

   tree1==tree2 माध्यम set(tree1.children)==set(tree2.children)

2. सामान्य खोज पेड़ (फ्लिप देखभाल) तुल्यता:

   tree1==tree2 माध्यम list(tree1.children)==list(tree2.children)

द्विआधारी पेड़ के लिए, ऊपर परिभाषाएँ जो समर्थन करता है, किसी भी भाषा में के रूप में लिखा काम करेंगे listऔर setडेटाटाइप्स (अजगर सेट unhashable डेटाटाइप्स पर फिर भी गला घोंटना होगा)। फिर भी, नीचे कुछ और वर्बोज़ और बदसूरत सी / जावा की तरह परिभाषाएं दी गई हैं:

1. संस्थानिक तुल्यता:

   t1==t2 माध्यम (t1.left==t2.left and t1.right==t2.right) or (t1.left==t2.right and t1.right==t2.left)

2. क्रमबद्ध पेड़ तुल्यता:

   t1==t2 माध्यम (t1.left==t2.left and t1.right==t2.right)

परिभाषाएँ ऊपर पुनरावर्ती कर रहे हैं; जो है, वे यह मान समानता subtrees और आधार मामलों में पहले से ही है, यह है जिसके लिए परिभाषित किया गया है।

पक्षीय लेख:

बोली: tree1-> बच्चे == tree2-> बच्चे

यह एक वैध बयान है, क्योंकि एक पेड़ नोड एक भी बच्चे नहीं है नहीं है।

मैं सवाल पढ़ते हैं: दो द्विआधारी पेड़ को देखते हुए पेड़ में प्रत्येक गहराई के लिए, कि क्या अपने बच्चों की सेट एक दूसरे के में कवर कर रहे हैं लगता है।

यह अपेक्षाकृत आसान कोडित किया जा सकता है।

रूबी में प्रत्यावर्तन के बिना समाधान

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

रूबी वाक्य रचना टिप्स:

• (1) सरणी में तत्व डालने: arr << elem; इस मामले में for_checkसरणियों के सरणी है
• (2) समानांतर काम: t1,t2 = [item1, item2]। के समानarr = [item1, item2]; t1 = arr[0]; t2 = arr[1]
• (3) t1_children == t2_childrenवस्तुओं के इस प्रकार के लिए == की इसी व्यवहार ग्रहण किया। अधिक वर्बोज़ हो जाएगा t1_children.map { |el| el.val } == t2_children.map { |el| el.val }- यहाँ mapVals की सरणी पैदा करता है।

केननिज़ैषण दृष्टिकोण ने सुझाव दिया का उपयोग कर पेड़ की तुलना करें @mcdowella । अंतर यह है कि मेरे दृष्टिकोण की आवश्यकता नहीं है है O(N)पेड़ में एक नोड के अतिरिक्त मेमोरी wrt संख्या:

# 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()आवश्यकता है O(N*M)कदम और O(log(N)*M)एक पेड़ है, जहां में सभी नोड्स उपज के लिए स्मृति Nनोड्स की कुल संख्या है Mबच्चों प्रत्येक नोड है (यह द्विआधारी पेड़ों के लिए 2) की संख्या।

canonorder()आसानी से किसी भी नोड प्रतिनिधित्व और बच्चों के किसी भी संख्या के लिए सामान्यीकृत किया जा सकता है। canonwalk()केवल यह है कि एक पेड़ एक दृश्य के रूप में इसके तत्काल बच्चों को एक्सेस कर सकें।

तुलना समारोह है कि कॉल 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

उदाहरण

    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)

उत्पादन

True