ഒരു ബൈനറി ട്രീ നോഡിൽ നിന്ന് മറ്റൊരു LeetCode സൊല്യൂഷനിലേക്കുള്ള ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങൾ

പ്രശ്ന പ്രസ്താവന: ബൈനറി ട്രീ നോഡിൽ നിന്ന് മറ്റൊരു ലീറ്റ്കോഡ് സൊല്യൂഷനിലേക്കുള്ള ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങൾ - നിങ്ങൾക്ക് n നോഡുകളുള്ള ഒരു ബൈനറി ട്രീയുടെ റൂട്ട് നൽകിയിരിക്കുന്നു. ഓരോ നോഡിനും 1 മുതൽ n വരെയുള്ള ഒരു മൂല്യം പ്രത്യേകമായി നൽകിയിട്ടുണ്ട്. സ്റ്റാർട്ട് നോഡുകളുടെ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു പൂർണ്ണസംഖ്യ ആരംഭ മൂല്യവും ലക്ഷ്യസ്ഥാനത്തിന്റെ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്ന മറ്റൊരു പൂർണ്ണസംഖ്യ മൂല്യവും നിങ്ങൾക്ക് നൽകിയിരിക്കുന്നു ...

കൂടുതല് വായിക്കുക

ബൈനറി ട്രീ ലീറ്റ്കോഡ് സൊല്യൂഷന്റെ ലംബമായ ക്രമം

ബൈനറി ട്രീയുടെ ലംബ ക്രമം ട്രാവേഴ്സൽ ലീറ്റ്കോഡ് സൊല്യൂഷൻ പറയുന്നു - ഒരു ബൈനറി ട്രീയുടെ റൂട്ട് നൽകിയാൽ, ബൈനറി ട്രീയുടെ ലംബമായ ക്രമം കണക്കാക്കുക. സ്ഥാനത്തുള്ള ഓരോ നോഡിനും (വരി, കോൾ), അതിന്റെ ഇടത്, വലത് കുട്ടികൾ യഥാക്രമം (വരി + 1, കോൾ - 1), (വരി + 1, കോൾ + 1) എന്നീ സ്ഥാനങ്ങളിലായിരിക്കും. …

കൂടുതല് വായിക്കുക

സം റൂട്ട് ടു ലീഫ് നമ്പറുകൾ LeetCode പരിഹാരം

പ്രശ്ന പ്രസ്താവന സം റൂട്ട് ടു ലീഫ് നമ്പറുകൾ LeetCode സൊല്യൂഷൻ പറയുന്നു - 0 മുതൽ 9 വരെയുള്ള അക്കങ്ങൾ മാത്രമുള്ള ഒരു ബൈനറി ട്രീയുടെ റൂട്ട് നിങ്ങൾക്ക് നൽകിയിരിക്കുന്നു. മരത്തിലെ ഓരോ റൂട്ട്-ടു-ഇഫ് പാതയും ഒരു സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. ഉദാഹരണത്തിന്, റൂട്ട്-ടു-ലീഫ് പാത്ത് 1 -> 2 -> 3 എന്നത് 123 എന്ന സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. എല്ലാ റൂട്ട്-ടു-ലീഫ് നമ്പറുകളുടെയും ആകെ തുക തിരികെ നൽകുക. ടെസ്റ്റ്…

കൂടുതല് വായിക്കുക

ബൈനറി ട്രീ ഇനോർഡർ ട്രാവേഴ്സൽ ലീറ്റ്കോഡ് സൊല്യൂഷൻ

പ്രശ്ന പ്രസ്താവന: ബൈനറി ട്രീ ഇനോർഡർ ട്രാവേഴ്സൽ ലീറ്റ്കോഡ് സൊല്യൂഷൻ ഒരു ബൈനറി ട്രീയുടെ റൂട്ട് നൽകുമ്പോൾ, അതിന്റെ നോഡുകളുടെ മൂല്യങ്ങളുടെ ക്രമരഹിതമായ ട്രാവേസൽ തിരികെ നൽകുക. ഉദാഹരണം 1: ഇൻപുട്ട്: റൂട്ട് = [1,null,2,3] ഔട്ട്പുട്ട്: [1,3,2] ഉദാഹരണം 2: ഇൻപുട്ട്: റൂട്ട് = [] ഔട്ട്പുട്ട്: [] ഉദാഹരണം 3: ഇൻപുട്ട്: റൂട്ട് = [1] ഔട്ട്പുട്ട്: [1] നിയന്ത്രണങ്ങൾ: ഇതിലെ നോഡുകളുടെ എണ്ണം…

കൂടുതല് വായിക്കുക

ലിങ്ക്ഡ് ലിസ്റ്റ് LeetCode സൊല്യൂഷനിലേക്ക് ബൈനറി ട്രീ പരത്തുക

ലിങ്ക്ഡ് ലിസ്റ്റ് LeetCode സൊല്യൂഷനിലേക്ക് ബൈനറി ട്രീ പരത്തുക എന്ന് പറയുന്നു - നൽകിയിരിക്കുന്നത് root ഒരു ബൈനറി ട്രീയുടെ, വൃക്ഷത്തെ ഒരു "ലിങ്ക്ഡ് ലിസ്റ്റ്" ആയി പരത്തുക:

  • "ലിങ്ക് ചെയ്ത ലിസ്റ്റ്" അത് തന്നെ ഉപയോഗിക്കണം TreeNode ക്ലാസ് എവിടെ right ചൈൽഡ് പോയിന്റർ ലിസ്റ്റിലെ അടുത്ത നോഡിലേക്കും ദി left കുട്ടി സൂചിക എപ്പോഴും null.
  • "ലിങ്ക് ചെയ്‌ത പട്ടിക" a-യുടെ അതേ ക്രമത്തിലായിരിക്കണം പ്രി ഓർഡർ ട്രാവെർസൽ ബൈനറി ട്രീയുടെ.

 

ഉദാഹരണം 1:

ലിങ്ക്ഡ് ലിസ്റ്റ് LeetCode സൊല്യൂഷനിലേക്ക് ബൈനറി ട്രീ പരത്തുകഇൻപുട്ട്:

 root = [1,2,5,3,4,null,6]

ഔട്ട്പുട്ട്:

 [1,null,2,null,3,null,4,null,5,null,6]

ഉദാഹരണം 2:

ഇൻപുട്ട്:

 root = []

ഔട്ട്പുട്ട്:

 []

ഉദാഹരണം 3:

ഇൻപുട്ട്:

 root = [0]

ഔട്ട്പുട്ട്:

 [0]

 

അൽഗോരിതം -

ഐഡിയ -

  • ഒരു ബൈനറി ട്രീ പരത്തുന്നതിന്, ഞങ്ങൾ ആദ്യം ഇടത് സബ്ട്രീയുടെ ഏറ്റവും വലത് മൂലകം കണ്ടെത്തും, വലത് മൂലകം ലഭിച്ചതിന് ശേഷം ആ നോഡിന്റെ വലത് പോയിന്ററിനെ തന്നിരിക്കുന്ന ട്രീയുടെ വലത് സബ്ട്രീയുമായി ബന്ധിപ്പിക്കും.
  • ഘട്ടം 2-ൽ നമ്മൾ റൂട്ട് നോഡിന്റെ വലത് പോയിന്ററിനെ ഇടത്-സബ്ട്രീയുമായി ലിങ്ക് ചെയ്യുകയും ഇടത്-സബ്ട്രീയെ ശൂന്യമായി സജ്ജമാക്കുകയും ചെയ്യും.
  • ഘട്ടം 3-ൽ ഇപ്പോൾ നമ്മുടെ റൂട്ട് നോഡ് വലത്-സബ്ട്രീ നോഡാണ്, ഈ നോഡിലും അതേ പ്രക്രിയ സംഭവിക്കും, ഇടത് ഭാഗങ്ങളെല്ലാം അസാധുവാകുന്നതുവരെ പ്രക്രിയ തുടരും.

ഫ്ലാറ്റൻ ബൈനറി ട്രീയുടെ ലിങ്ക്ഡ് ലിസ്റ്റിലേക്കുള്ള സമീപനം Leetcode പരിഹാരം -

– ആദ്യം, ഞാൻ ഒരു ലൂപ്പ് പ്രവർത്തിപ്പിക്കും, അതായത് while(റൂട്ട് != null) തുടർന്ന് രണ്ട് വേരിയബിളുകൾ എടുത്ത് ഇടത്-സബ്‌ട്രീ സംഭരിക്കും.

– തുടർന്ന് while(k.left != null) ഉപയോഗിച്ച് ഇടത്-സബ്‌ട്രീയുടെ വലത്തേയറ്റത്തെ നോഡ് പരിശോധിക്കുകയും ആ നോഡിനെ വലത് സബ്‌ട്രീയുമായി ലിങ്ക് ചെയ്യുകയും ചെയ്യും (k.right = root.right).

– തുടർന്ന് റൂട്ട് നോഡിന്റെ വലത് പോയിന്റർ ഇടത് സബ്ട്രീ (root.right = ഇടത്) ഉപയോഗിച്ച് ലിങ്ക് ചെയ്യുകയും റൂട്ട് നോഡിന്റെ ഇടത് പോയിന്റർ null (root.left=null) ആയി സജ്ജമാക്കുകയും (root.left=null) ആയി അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്യും, അതിനാൽ ഇപ്പോൾ റൂട്ട് ശരിയാണ് സബ്ട്രീ നോഡ്.

- എല്ലാ ഇടത്-സബ്ട്രീ ഭാഗങ്ങളും വലത് സബ്ട്രീ ആകുന്നത് വരെ ഈ പ്രക്രിയ തുടരും. അതിനാൽ, ബൈനറി മരം പരന്നുപോകും.

 

ലിങ്ക്ഡ് ലിസ്റ്റ് LeetCode സൊല്യൂഷനിലേക്ക് ബൈനറി ട്രീ പരത്തുക

ലിങ്ക്ഡ് ലിസ്റ്റ് LeetCode സൊല്യൂഷനിലേക്ക് ബൈനറി ട്രീ പരത്തുക

പൈത്തൺ പരിഹാരം:

class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        while(root):
            
            if root.left:
                
                k = root.left
                temp = root.left
            
            
                while(k.right):
                    k = k.right
            
                k.right = root.right
            
                root.right = temp
            
                root.left = None
            
            root = root.right

ജാവ പരിഹാരം:

class Solution {
    public void flatten(TreeNode root) {       
        while (root != null) {
            if (root.left != null) {
                TreeNode k = root.left;
                TreeNode temp = root.left;
                while (k.right != null) k = k.right;
                k.right = root.right;
                root.right = temp;
                root.left = null;
            }
            root = root.right;
        }
    }
}

സമയ സങ്കീർണ്ണത: O(N)

ബഹിരാകാശ സങ്കീർണ്ണത: O (1)

നമ്മൾ ഒരിക്കൽ മാത്രം സഞ്ചരിച്ചതിനാൽ, സമയ സങ്കീർണ്ണത o(n) ആയിരിക്കും.

ഞങ്ങൾ അധിക സ്ഥലമൊന്നും എടുത്തിട്ടില്ലാത്തതിനാൽ, സ്‌പെയ്‌സ് കോംപ്ലക്‌സിറ്റി o(1) സ്ഥിരമായ അധിക സ്‌പെയ്‌സ് ആയിരിക്കും.

സമാനമായ ചോദ്യം - https://www.tutorialcup.com/interview/linked-list/flattening-linked-list.htm

N-Ary Tree LeetCode സൊല്യൂഷന്റെ വ്യാസം

പ്രശ്ന പ്രസ്താവന : N-Ary Tree LeetCode സൊല്യൂഷന്റെ വ്യാസം - N-ary ട്രീയുടെ ഒരു റൂട്ട് നൽകിയാൽ, നിങ്ങൾ മരത്തിന്റെ വ്യാസത്തിന്റെ നീളം കണക്കാക്കേണ്ടതുണ്ട്. ഒരു N-ary മരത്തിന്റെ വ്യാസം വൃക്ഷത്തിലെ ഏതെങ്കിലും രണ്ട് നോഡുകൾക്കിടയിലുള്ള ഏറ്റവും ദൈർഘ്യമേറിയ പാതയുടെ നീളമാണ്. ഈ പാത ആവാം ഇല്ലാതിരിക്കാം...

കൂടുതല് വായിക്കുക

ഒരു ബൈനറി ട്രീ ലീറ്റ്കോഡ് സൊല്യൂഷന്റെ ഏറ്റവും താഴ്ന്ന പൊതു പൂർവ്വികൻ

പ്രശ്ന പ്രസ്താവന ബൈനറി ട്രീയുടെ ഏറ്റവും താഴ്ന്ന പൊതു പൂർവ്വികൻ ലീറ്റ്കോഡ് സൊല്യൂഷൻ - "ബൈനറി ട്രീയുടെ ഏറ്റവും താഴ്ന്ന പൊതു പൂർവ്വികൻ" ബൈനറി ട്രീയുടെ വേരും മരത്തിന്റെ രണ്ട് നോഡുകളും നൽകിയതായി പ്രസ്താവിക്കുന്നു. ഈ രണ്ട് നോഡുകളുടെയും ഏറ്റവും താഴ്ന്ന പൊതു പൂർവ്വികനെ നമ്മൾ കണ്ടെത്തേണ്ടതുണ്ട്. ഏറ്റവും കുറഞ്ഞ സാധാരണ…

കൂടുതല് വായിക്കുക

ഓരോ നോഡിലും അടുത്ത വലത് പോയിന്ററുകൾ പോപ്പുലേറ്റിംഗ് Leetcode സൊല്യൂഷനിൽ

പ്രശ്‌ന പ്രസ്താവന ഓരോ നോഡിലും പോപ്പുലേറ്റിംഗ് അടുത്ത വലത് പോയിന്ററുകൾ LeetCode സൊല്യൂഷൻ - "ഓരോ നോഡിലും അടുത്ത വലത് പോയിന്ററുകൾ പോപ്പുലേറ്റിംഗ്" പ്രസ്‌താവിക്കുന്നു, അത് തികഞ്ഞ ബൈനറി ട്രീയുടെ റൂട്ട് നൽകിയിരിക്കുന്നു, കൂടാതെ നോഡിന്റെ ഓരോ അടുത്ത പോയിന്ററും അതിന്റെ അടുത്ത വലത് നോഡിലേക്ക് പോപ്പുലേറ്റ് ചെയ്യേണ്ടതുണ്ട്. അടുത്തത് ഇല്ലെങ്കിൽ…

കൂടുതല് വായിക്കുക

നോഡുകൾ ഇല്ലാതാക്കി ഫോറസ്റ്റ് ലീറ്റ്കോഡ് സൊല്യൂഷൻ തിരികെ നൽകുക

പ്രശ്‌ന പ്രസ്താവന ഡിലീറ്റ് നോഡുകൾ, റിട്ടേൺ ഫോറസ്റ്റ് ലീറ്റ് കോഡ് സൊല്യൂഷൻ - "നോഡുകൾ ഇല്ലാതാക്കി ഫോറസ്റ്റ് തിരികെ നൽകുക" എന്ന് പറയുന്നത് ഓരോ നോഡിനും പ്രത്യേക മൂല്യമുള്ള ബൈനറി ട്രീയുടെ റൂട്ട് നൽകിയിട്ടുണ്ട്. ഞങ്ങൾക്ക് ഒരു അറേയും നൽകിയിട്ടുണ്ട്, to_delete, അതിൽ അടങ്ങിയിരിക്കുന്ന മൂല്യങ്ങളുള്ള എല്ലാ നോഡുകളും ഇല്ലാതാക്കേണ്ടതുണ്ട്.

കൂടുതല് വായിക്കുക

ബൈനറി സെർച്ച് ട്രീ ലീറ്റ്കോഡ് സൊല്യൂഷൻ വീണ്ടെടുക്കുക

പ്രശ്ന പ്രസ്താവന റിക്കവർ ബൈനറി സെർച്ച് ട്രീ ലീറ്റ്കോഡ് സൊല്യൂഷൻ - "ബൈനറി സെർച്ച് ട്രീ വീണ്ടെടുക്കുക" എന്ന് പറയുന്നത് ബൈനറി സെർച്ച് ട്രീയുടെ റൂട്ട് നൽകിയിട്ടുണ്ട്, ഇവിടെ കൃത്യമായി രണ്ട് നോഡുകളുടെ മൂല്യങ്ങൾ അബദ്ധത്തിൽ കൈമാറ്റം ചെയ്യപ്പെടുന്നു. മരത്തിന്റെ ഘടന മാറ്റാതെ തന്നെ വീണ്ടെടുക്കണം. ഉദാഹരണം: ഇൻപുട്ട്: റൂട്ട് = [1,3,null,null,2] ഔട്ട്പുട്ട്: [3,1,null,null,2] …

കൂടുതല് വായിക്കുക

Translate »