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

Python में दिए गए बाइनरी ट्री के वर्टिकल लेवल को क्रमबद्ध है या नहीं जांचना


मान लीजिए हमारे पास बाइनरी ट्री है; हमें जांचना है कि बाइनरी ट्री का दिया गया वर्टिकल लेवल क्रमबद्ध है या नहीं। जब दो नोड ओवरलैप हो रहे हों, तो जांचें कि वे उस लेवल से संबंधित हैं जहां वे क्रमबद्ध क्रम में हैं।

तो, यदि इनपुट l = -1 है

Python में दिए गए बाइनरी ट्री के वर्टिकल लेवल को क्रमबद्ध है या नहीं जांचना

तो आउटपुट True होगा, क्योंकि लेवल -1 में तत्व 3, 7 हैं और वे क्रमबद्ध हैं।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

  • यदि root null है, तो

    • True वापस करें

  • previous_value := -inf

  • current_level := 0

  • current_node := मान 0 के साथ एक नया ट्री नोड

  • q नामक एक डीक्यू परिभाषित करें

  • q के अंत में (root, 0) डालें

  • जब q खाली नहीं है, करें

    • current_node := q[0, 0]

    • current_level := q[0, 1]

    • q के बाएं से तत्व हटाएं

    • यदि current_level, लेवल के समान है, तो

      • यदि previous_value <= current_node.val, तो

        • previous_value := current_node.val

      • अन्यथा,

        • False वापस करें

    • यदि current_node.left null नहीं है, तो

      • q के अंत में (current_node.left, current_level - 1) डालें

    • यदि current_node.right गैर-null है, तो

      • q के अंत में (current_node.right, current_level + 1) डालें

  • True वापस करें

उदाहरण

बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

from collections import deque from sys import maxsize INT_MIN = -maxsize class TreeNode:     def __init__(self, key):         self.val = key         self.left = None         self.right = None def are_elements_sorted(root, level):     if root is None:         return True     previous_value = INT_MIN     current_level = 0     current_node = TreeNode(0)     q = deque()     q.append((root, 0))     while q:         current_node = q[0][0]         current_level = q[0][1]         q.popleft()         if current_level == level:             if previous_value <= current_node.val:                 previous_value = current_node.val             else:                 return False         if current_node.left:             q.append((current_node.left, current_level - 1))         if current_node.right:             q.append((current_node.right, current_level + 1))     return True root = TreeNode(2) root.left = TreeNode(3) root.right = TreeNode(6) root.left.left = TreeNode(8) root.left.right = TreeNode(5) root.left.right.left = TreeNode(7) level = -1 print(are_elements_sorted(root, level))

इनपुट

root = TreeNode(2) root.left = TreeNode(3) root.right = TreeNode(6) root.left.left = TreeNode(8) root.left.right = TreeNode(5) root.left.right.left = TreeNode(7)

आउटपुट

True

  1. पायथन में दिए गए बाइनरी ट्री में सबसे बड़ा परफेक्ट सबट्री खोजें पायथन में दिए गए बाइनरी ट्री में सबसे बड़ा परफेक्ट सबट्री खोजें

    मान लीजिए हमारे पास एक दिया गया बाइनरी ट्री है; हमें उस दिए गए बाइनरी ट्री में सबसे बड़े परफेक्ट सब-ट्री का आकार ढूंढना है। जैसा कि हम जानते हैं, परफेक्ट बाइनरी ट्री एक बाइनरी ट्री है जिसमें सभी आंतरिक नोड्स के दो बच्चे होते हैं और सभी पत्ते समान स्तर पर होते हैं।तो, यदि इनपुट इस तरह है:तो आउटपुट 3

  1. पायथन में बाइनरी ट्री उल्टा करें पायथन में बाइनरी ट्री उल्टा करें

    मान लीजिए हमारे पास एक बाइनरी ट्री है। हमारा कार्य एक उल्टा बाइनरी ट्री बनाना है। यदि ट्री नीचे जैसा है: उल्टा ट्री इस तरह होगा: इसे हल करने के लिए हम एक पुनरावर्ती दृष्टिकोण का उपयोग करेंगे: यदि रूट null है, तो वापस करें बाएं और दाएं पॉइंटर्स को स्वैप करें बाएं सबट्री और दाएं सबट्री के लिए पुनर

  1. पायथन में क्रमबद्ध सरणी को बाइनरी सर्च ट्री में बदलें पायथन में क्रमबद्ध सरणी को बाइनरी सर्च ट्री में बदलें

    मान लीजिए हमारे पास एक क्रमबद्ध सरणी A है। हमें एक ऊंचाई-संतुलित बाइनरी सर्च ट्री उत्पन्न करना है। इस समस्या में, एक ऊंचाई-संतुलित बाइनरी ट्री वास्तव में एक बाइनरी ट्री है जिसमें हर नोड के दो सबट्री की गहराई 1 से अधिक नहीं होती। मान लीजिए सरणी [-10, -3, 0, 5, 9] जैसी है। तो एक संभावित आउटपुट होगा: