पायथन में लिंक्ड सूचियों के रूप में दर्शाई गई संख्याओं को खोजने का कार्यक्रम

मान लीजिए कि हमारे पास दो एकल लिंक की गई सूची L1 और L2 है, जिनमें से प्रत्येक पहले कम से कम महत्वपूर्ण अंकों वाली संख्या का प्रतिनिधित्व करती है, हमें सारांशित लिंक्ड सूची ढूंढनी होगी।

इसलिए, यदि इनपुट L1 =[5,6,4] L2 =[2,4,8] जैसा है, तो आउटपुट [7, 0, 3, 1, ]

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

• कैरी :=0

• res :=मान 0 के साथ एक नया नोड

• वर्तमान:=रेस

• जबकि L1 खाली नहीं है या L2 खाली नहीं है या कैरी गैर-शून्य है, करें

  • l0_val :=L1 का मान यदि L1 खाली नहीं है अन्यथा 0

  • l1_val :=L2 का मान यदि L2 खाली नहीं है अन्यथा 0

  • योग_ :=l0_val + l1_val

  • कैरी :=भागफल (sum_ + कैरी) / 10

  • add_val :=शेष (sum_ + कैरी) / 10

  • curr.next :=मूल्य add_val के साथ एक नया नोड

  • curr :=अगला curr

  • L1 :=L1 के बगल में यदि L1 खाली नहीं है अन्यथा शून्य

  • L2 :=L2 के बगल में यदि L2 खाली नहीं है अन्यथा शून्य

• अगली धारा :=शून्य

• रेस के आगे लौटें

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

उदाहरण

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

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_list(head):
   ptr = head
   print('[', end = "")
   while ptr:
      print(ptr.val, end = ", ")
      ptr = ptr.next
   print(']')

class Solution:
   def solve(self, L1, L2):
      carry = 0
      res = ListNode(0)
      curr = res

      while L1 or L2 or carry:
         l0_val = L1.val if L1 else 0
         l1_val = L2.val if L2 else 0
         sum_ = l0_val + l1_val
         carry, add_val = divmod(sum_ + carry, 10)

         curr.next = ListNode(add_val)
         curr = curr.next

         L1 = L1.next if L1 else None
         L2 = L2.next if L2 else None

      curr.next = None

return res.next

ob = Solution()
L1 = make_list([5,6,4])
L2 = make_list([2,4,8])
print_list(ob.solve(L1, L2))

इनपुट

[5,6,4], [2,4,8]

आउटपुट

[7, 0, 3, 1, ]