पायथन में बाइनरी सर्च ट्री से लिंक की गई सूची बनाने का कार्यक्रम

मान लीजिए कि हमारे पास आकार n की एक क्रमबद्ध लिंक्ड सूची नोड है, हमें k =फ़्लोर (n / 2) के मान को रूट के रूप में सेट करके एक बाइनरी सर्च ट्री बनाना होगा। फिर kth नोड के बाईं ओर लिंक की गई सूची का उपयोग करके बाएं उपट्री का पुन:निर्माण करना। और kth नोड के दाईं ओर लिंक की गई सूची का उपयोग करके सही सबट्री का पुन:निर्माण करना।

इसलिए, अगर इनपुट [2,4,5,7,10,15] जैसा है, तो आउटपुट होगा

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

• हल करने के तरीके को परिभाषित करें (), यह नोड लेगा

• यदि नोड शून्य है, तो

  • वापसी शून्य

• अगर अगला नोड शून्य है, तो

  • नोड के मान के साथ एक नया ट्री नोड लौटाएं

• धीमा:=नोड, तेज़:=नोड

• पिछला :=कोई नहीं

• जबकि उपवास और अगले उपवास शून्य नहीं हैं, करें

  • पिछला :=धीमा

  • धीमा :=धीमे के आगे

  • उपवास :=उपवास के अगले के बाद

• पिछला का अगला :=कोई नहीं

• जड़:=एक नया ट्री नोड जिसका मान धीमा है

• रूट के बाईं ओर:=हल करें (नोड)

• जड़ का दाहिना भाग :=हल करें (धीमे के आगे)

• वापसी जड़

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

उदाहरण

class ListNode:
   def __init__(self, data, next = None):
      self.val = data
      self.next = next
class TreeNode:
   def __init__(self, data, left = None, right = None):
      self.data = data
      self.left = left
      self.right = right

def make_list(elements):
   head = ListNode(elements[0])
   for element in elements[1:]:
      ptr = head
      while ptr.next:
         ptr = ptr.next
      ptr.next = ListNode(element)
return head

def print_tree(root):
   if root is not None:
      print_tree(root.left)
      print(root.data, end = ', ')
      print_tree(root.right)

class Solution:
   def solve(self, node):
      if not node:
         return None
      if not node.next:
         return TreeNode(node.val)
      slow = fast = node
      prev = None
      while fast and fast.next:
         prev = slow
         slow = slow.next
         fast = fast.next.next
      prev.next = None
      root = TreeNode(slow.val)
      root.left = self.solve(node)
      root.right = self.solve(slow.next)

      return root

ob = Solution()
head = make_list([2,4,5,7,10,15])
root = ob.solve(head)
print_tree(root)

इनपुट

[2,4,5,7,10,15]

आउटपुट

2, 4, 5, 7, 10, 15,