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

किसी दिए गए पेड़ के नॉन लीफ नोड्स की संख्या की गणना करने के लिए पायथन प्रोग्राम

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

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

उदाहरण

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

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

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

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

   def count_non_leaf_node(self):
      nonleaf_count = 0
      if self.children != []:
         nonleaf_count = 1
      for child in self.children:
         nonleaf_count = nonleaf_count + child.count_non_leaf_node()
      return nonleaf_count

tree = None

print('Menu (this assumes no duplicate keys)')
print('add <data> at root')
print('add <data> below <data>')
print('count')
print('quit')

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

   operation = my_input[0].strip().lower()
   if operation == 'add':
      data = int(my_input[1])
      newNode = Tree_structure(data)
      suboperation = my_input[2].strip().lower()
      if suboperation == 'at':
         tree = newNode
      elif suboperation == 'below':
         position = my_input[3].strip().lower()
         key = int(position)
         ref_node = None
         if tree is not None:
            ref_node = tree.search_val(key)
         if ref_node is None:
            print('No such key.')
            continue
         ref_node.add_vals(newNode)

   elif operation == 'count':
      if tree is None:
         print('The tree is empty ')
      else:
         count = tree.count_non_leaf_node()
         print('The number of non-leaf nodes are : {}'.format(count))

   elif operation == 'quit':
      break

आउटपुट

Menu (this assumes no duplicate keys)
add <data> at root
add <data> below <data>
count
quit
What operation would you like to perform ? add 34 at root
What operation would you like to perform ? add 78 below 34
What operation would you like to perform ? add 56 below 78
What operation would you like to perform ? add 90 below 56
What operation would you like to perform ? count
The number of non-leaf nodes are : 3
What operation would you like to perform ? quit

स्पष्टीकरण

  • 'ट्री_स्ट्रक्चर' वर्ग बनाया गया है।

  • यह 'कुंजी' को True पर सेट करता है और पेड़ के बच्चों के लिए एक खाली सूची सेट करता है।

  • इसमें एक 'set_root' फंक्शन है जो ट्री के लिए रूट वैल्यू सेट करने में मदद करता है।

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

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

  • 'काउंट_नॉन_लीफ_नोड्स' नाम की एक अन्य विधि परिभाषित की गई है, जो ट्री के नॉन लीफ नोड्स की गिनती प्राप्त करने में मदद करती है।

  • यह एक पुनरावर्ती कार्य है।

  • चार विकल्प दिए गए हैं, जैसे 'रूट में जोड़ें', 'नीचे जोड़ें', 'गिनती' और 'छोड़ें'।

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

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


  1. पायथन में दिए गए किनारों को शामिल करने वाले अद्वितीय पथों की संख्या की गणना करने का कार्यक्रम

    मान लीजिए कि हमारे पास (u, v) के रूप में किनारों की एक सूची है और ये एक पेड़ का प्रतिनिधित्व कर रहे हैं। प्रत्येक किनारे के लिए हमें इनपुट में दिए गए क्रम में उसी क्रम में अद्वितीय पथों की कुल संख्या ज्ञात करनी होगी जिसमें उक्त किनारे शामिल हैं। इसलिए, यदि इनपुट किनारों की तरह है =[[0, 1],[0, 2],[1

  1. पायथन में एक बाइनरी ट्री के लीफ और नॉन-लीफ नोड्स को खोजने का कार्यक्रम

    मान लीजिए कि हमारे पास एक बाइनरी ट्री है, हमें दो नंबरों की एक सूची ढूंढनी है जहां पहली संख्या पेड़ में पत्तियों की गिनती है और दूसरी संख्या गैर-पत्ती नोड्स की गिनती है। तो, अगर इनपुट पसंद है तब आउटपुट (3, 2) होगा, क्योंकि 3 पत्ते और 2 गैर-पत्ती नोड हैं। इसे हल करने के लिए, हम इन चरणों का पालन

  1. किसी दिए गए स्ट्रिंग में सेट का उपयोग करके स्वरों की संख्या गिनने के लिए पायथन प्रोग्राम

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