मैं उलझन में हूं कि कैसे head.next अगले मान के बजाय पूरी सूची लौटाता है जैसे l1,l2,dummy .next नीचे दिए गए कोड में करता है। विशेष रूप से मैं सोच रहा हूं कि कैसे head.next एक संपूर्ण क्रमबद्ध सरणी देता है और -1 मान को छोड़ देता है जो दूसरी पंक्ति पर इनपुट था।

let mergeTwoLists = function (l1, l2) {
  let dummy = new ListNode(-1);
  let head = dummy;

  while (l1 !== null && l2 !== null) {
    if (l1.val <= l2.val) {
      dummy.next = l1;
      l1 = l1.next;
    } else {
      dummy.next = l2;
      l2 = l2.next;
    }
    dummy = dummy.next;
  }

  if (l1 !== null) {
    dummy.next = l1;
  } else {
    dummy.next = l2;
  }

  return head.next;
};

class ListNode {
  constructor(val = null, next = null) {
    this.val = val;
    this.next = next;
  }
}
0
Tyrique Daniel 26 अक्टूबर 2020, 02:46

1 उत्तर

सबसे बढ़िया उत्तर

शायद यह देखने में मदद करता है कि सूची कैसे बनाई जाती है:

इनपुट को मान [३, ९] के साथ एक सूची होने दें और दूसरा केवल [४] के साथ:

 l1
 ↓
 3 → 9 → null

 l2
 ↓
 4 → null

लूप शुरू होने से पहले एक नया नोड बनाया जाता है:

head
 ↓
-1
 ↑
dummy

लूप अपनी पहली पुनरावृत्ति करेगा, और if स्थिति सत्य है। पहले dummmy.next को अनुकूलित किया जाता है, जो इस स्थिति की ओर ले जाता है:

head l1
 ↓   ↓
-1 → 3 → 9 → null
 ↑
dummy    

 l2
 ↓
 4 → null

... और फिर l1 को एक नया संदर्भ पुन: असाइन किया जाता है:

head     l1
 ↓       ↓
-1 → 3 → 9 → null
 ↑
dummy    

 l2
 ↓
 4 → null

लूप में अंतिम कथन dummy के लिए एक नया संदर्भ प्रदान करता है:

head     l1
 ↓       ↓
-1 → 3 → 9 → null
     ↑
    dummy    

 l2
 ↓
 4 → null

लूप दूसरी बार पुनरावृत्त होता है, और if स्थिति अब झूठी है, इसलिए हम else ब्लॉक में आ जाते हैं। पहले dummmy.next को अनुकूलित किया जाता है (यह l1 के साथ उसके लिंक को तोड़ देता है, और इसलिए मैं l1 और l2 के विज़ुअलाइज़ेशन को स्थानांतरित करता हूं):

head     l2
 ↓       ↓
-1 → 3 → 4 → null
     ↑
    dummy    

 l1
 ↓
 9 → null

... और फिर l1 को एक नया संदर्भ दिया जाता है, इस स्थिति में यह null बन जाता है:

head          l2
 ↓            ↓
-1 → 3 → 4 → null
     ↑
    dummy    

 l1
 ↓
 9 → null

लूप में अंतिम कथन dummy के लिए एक नया संदर्भ प्रदान करता है:

head          l2
 ↓            ↓
-1 → 3 → 4 → null
         ↑
        dummy    

 l1
 ↓
 9 → null

इस स्तर पर लूप की स्थिति अब सत्य नहीं है (l2 null है), और इसलिए if लूप का अनुसरण करने वाले ब्लॉक को निष्पादित किया जाता है। यह dummy.next को शेष (null नहीं) संदर्भ से जोड़ता है। फिर से, विज़ुअलाइज़ेशन के लिए, मैं l1 और l2 की स्थिति को स्वैप करता हूं:

head         l1
 ↓           ↓
-1 → 3 → 4 → 9 → null
         ↑
        dummy    

 l2
 ↓
null

अब हम अंतिम कथन पर आते हैं: return head.next। ध्यान दें कि कैसे head कभी उस नए नोड से दूर नहीं गया जो शुरुआत में बनाया गया था।

तो लौटा संदर्भ है:

head         l1
 ↓           ↓
-1 → 3 → 4 → 9 → null
     ↑
    returned    

 l2
 ↓
null

ध्यान दें कि कैसे head इस फ़ंक्शन के पूरे निष्पादन के दौरान -1 के साथ नोड को इंगित करता रहता है। मान -1 के साथ अस्थायी नोड कचरा एकत्र किया जाएगा, क्योंकि फ़ंक्शन के वापस आने के बाद इसे संदर्भित करने वाला कोई चर नहीं है (head एक स्थानीय चर है)।

2
trincot 26 अक्टूबर 2020, 10:10