Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> Python

एक बाइनरी ट्री में सभी नोड्स का योग खोजने के लिए पायथन प्रोग्राम

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

नीचे उसी का एक प्रदर्शन है -

उदाहरण

class Tree_struct:
   def __init__(self, data=None):
      self.key = data
      self.children = []

   def set_root(self, data):
      self.key = data

   def add_node(self, node):
      self.children.append(node)

   def search_node(self, key):
      if self.key == key:
         return self
      for child in self.children:
         temp = child.search_node(key)
         if temp is not None:
            return temp
      return None

   def sum_node(self):
      my_summation = self.key
      for child in self.children:
         my_summation = my_summation + child.sum_node()
      return my_summation

my_instance = None

print('Menu (assume no duplicate keys)')
print('add <data> at root')
print('add <data> below <data>')
print('sum')
print('quit')

while True:
   my_input = input('What operation would you do ? ').split()

   operation = my_input[0].strip().lower()
   if operation == 'add':
      data = int(my_input[1])
      new_node = Tree_struct(data)
      suboperation = my_input[2].strip().lower()
      if suboperation == 'at':
         my_instance = new_node
      elif suboperation == 'below':
         position = my_input[3].strip().lower()
         key = int(position)
         ref_node = None
         if my_instance is not None:
            ref_node = my_instance.search_node(key)
         if ref_node is None:
            print('No such key')
            continue
         ref_node.add_node(new_node)

   elif operation == 'sum':
      if my_instance is None:
         print('The tree is empty')
      else:
         my_summation = my_instance.sum_node()
         print('Sum of all nodes is: {}'.format(my_summation))

   elif operation == 'quit':
      break

आउटपुट

Menu (assume no duplicate keys)
add <data> at root
add <data> below <data>
sum
quit
What operation would you do ? add 5 at root
What operation would you do ? add 7 below 5
What operation would you do ? add 0 below 7
What operation would you do ? sum
Sum of all nodes is: 12
What operation would you do ? quit

स्पष्टीकरण

  • आवश्यक विशेषताओं वाला 'Tree_struct' वर्ग बनाया गया है।

  • इसमें एक 'init' फ़ंक्शन होता है जिसका उपयोग एक खाली सूची बनाने के लिए किया जाता है।

  • एक 'set_root' विधि परिभाषित की गई है जो बाइनरी ट्री के मूल मान को सेट करने में मदद करती है।

  • इसमें एक 'add_node' विधि है जो पेड़ में तत्वों को जोड़ने में मदद करती है।

  • 'Search_elem' नाम की एक विधि परिभाषित की गई है, जो एक विशिष्ट तत्व की खोज में मदद करती है।

  • 'sum_node' नाम की एक विधि परिभाषित की गई है, जो पेड़ के तत्वों को जोड़ने और योग खोजने में मदद करती है।

  • एक उदाहरण बनाया जाता है और 'कोई नहीं' को असाइन किया जाता है।

  • उपयोगकर्ता इनपुट उस ऑपरेशन के लिए लिया जाता है जिसे निष्पादित करने की आवश्यकता होती है।

  • उपयोगकर्ता की पसंद के आधार पर, ऑपरेशन किया जाता है।

  • प्रासंगिक आउटपुट कंसोल पर प्रदर्शित होता है।


  1. पायथन में एक बाइनरी ट्री की अधिकतम चौड़ाई खोजने का कार्यक्रम

    मान लीजिए हमारे पास एक बाइनरी ट्री है, हमें ट्री में किसी भी स्तर की अधिकतम चौड़ाई ज्ञात करनी है। यहां एक स्तर की चौड़ाई उन नोड्स की संख्या है जो सबसे बाएं नोड और सबसे दाएं नोड के बीच हो सकते हैं। तो, अगर इनपुट . जैसा है तो आउटपुट 2 . होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे- न्य

  1. पायथन प्रोग्राम में सरणी का योग ज्ञात करें

    इस लेख में, हम नीचे दिए गए समस्या कथन के समाधान के बारे में जानेंगे। समस्या कथन - हमें एक सरणी दी गई है, जिसकी हमें सरणी के योग की गणना करने की आवश्यकता है। योग प्राप्त करने के लिए प्रत्येक अनुक्रमणिका में संपूर्ण सरणी और तत्व को पार करने के लिए पाशविक-बल दृष्टिकोण की चर्चा नीचे प्रत्येक अनुक्रमण

  1. सरणी का योग खोजने के लिए पायथन कार्यक्रम

    इस लेख में, हम दिए गए समस्या कथन को हल करने के लिए समाधान और दृष्टिकोण के बारे में जानेंगे। समस्या कथन एक इनपुट के रूप में एक सरणी को देखते हुए, हमें दिए गए सरणी के योग की गणना करने की आवश्यकता है। यहां हम ब्रूट-फोर्स अप्रोच का अनुसरण कर सकते हैं, यानी एक सूची को पार करना और प्रत्येक तत्व को एक खा