Sum Root to Leaf Numbers LeetCode ဖြေရှင်းချက်

Problem Statement Sum Root to Leaf Numbers LeetCode Solution ကပြောသည် - သင့်အား 0 မှ 9 ဂဏန်းများသာပါဝင်သော ဒွိသစ်ပင်၏အမြစ်ကို ပေးထားသည်။ သစ်ပင်ရှိ အမြစ်မှ အရွက်လမ်းကြောင်းတစ်ခုစီသည် နံပါတ်တစ်ခုကို ကိုယ်စားပြုသည်။ ဥပမာအားဖြင့်၊ အမြစ်မှအရွက်လမ်းကြောင်း 1 -> 2 -> 3 သည် နံပါတ် 123 ကိုကိုယ်စားပြုသည်။ အမြစ်မှအရွက်နံပါတ်အားလုံး၏ စုစုပေါင်းပေါင်းလဒ်ကို ပြန်ပေးပါ။ စမ်းသပ်မှု…

ဆက်ဖတ်ရန်

Binary Tree Inorder Traversal LeetCode ဖြေရှင်းချက်

ပြဿနာဖော်ပြချက်- Binary Tree Inorder Traversal LeetCode ဖြေရှင်းချက် binary tree ၏ အမြစ်ကို ပေးထားသည့်အတွက်၊ ၎င်း၏ nodes များ၏ တန်ဖိုးများ အစီအစဥ်ဖြတ်ကျော်မှုကို ပြန်ပေးသည်။ ဥပမာ 1- ထည့်သွင်းမှု- root = [1,null,2,3] အထွက်- [1,3,2] နမူနာ 2- ထည့်သွင်းမှု- root = [] အထွက်- [] ဥပမာ 3- ထည့်သွင်းမှု- root = [1] အထွက်- [1] ကန့်သတ်ချက်များ- အတွင်းရှိ node အရေအတွက်...

ဆက်ဖတ်ရန်

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree ပေးသည် ဟုဆိုသည်။ root ဒွိစုံသစ်ပင်၏ “ချိတ်ဆက်ထားသောစာရင်း” အဖြစ် သစ်ပင်ကို ပြားချပ်စေသည်-

  • "လင့်ခ်ချိတ်ထားသောစာရင်း" သည် အလားတူအသုံးပြုသင့်သည်။ TreeNode အတန်းဘယ်မှာလဲ။ right ကလေးညွှန်ပြချက်သည် စာရင်းရှိ နောက် node ကို ညွှန်ပြသည်။ left ကလေးညွှန်းကိန်းသည် အမြဲတမ်းဖြစ်သည်။ null.
  • "လင့်ခ်ချိတ်ထားသောစာရင်း" သည် a ကဲ့သို့ အစဉ်လိုက်ရှိသင့်သည်။ ကြိုတင်မှာယူမှု ဖြတ်သန်း ဒွိသစ်ပင်၏။

 

ဥပမာအား 1:

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Treeinput:

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

output:

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

ဥပမာအား 2:

input:

 root = []

output:

 []

ဥပမာအား 3:

input:

 root = [0]

output:

 [0]

 

အယ်လ်ဂိုရစ်သမ် –

IDEA –

  • ဒွိသစ်ပင်တစ်ပင်ကို ပြားချပ်စေရန်အတွက်၊ ဘယ်ဘက်သစ်ပင်၏ ညာဘက်ဆုံးဒြပ်စင်ကို ဦးစွာရှာတွေ့မည်ဖြစ်ပြီး ညာဘက်ဆုံးဒြပ်စင်ကိုရပြီးနောက် ပေးထားသောသစ်ပင်၏ ညာဘက်အခွဲနှင့် ထိုနိတ်၏ညာဘက်ညွှန်သူကို ချိတ်ဆက်မည်ဖြစ်သည်။
  • အဆင့် 2 တွင်ကျွန်ုပ်တို့သည် root node ၏ညာဘက်ညွှန်ပြချက်ကိုဘယ်-subtree နှင့်ချိတ်ဆက်ပြီး left-subtree ကို null အဖြစ်သတ်မှတ်မည်ဖြစ်သည်။
  • ယခု အဆင့် 3 တွင် ကျွန်ုပ်တို့၏ root node သည် right-subtree node တစ်ခုဖြစ်ပြီး တူညီသောလုပ်ငန်းစဉ်သည် ဤ node နှင့်ဖြစ်သွားမည်ဖြစ်ပြီး၊ ဘယ်ဘက်အပိုင်းများအားလုံး null ဖြစ်သွားသည်အထိ လုပ်ငန်းစဉ်သည် ဆက်လက်ရှိနေမည်ဖြစ်သည်။

ချိတ်ဆက်ထားသောစာရင်း Leetcode ဖြေရှင်းချက်သို့ Flatten Binary Tree အတွက်ချဉ်းကပ်နည်း

– ပထမတော့၊ ငါ while(root != null) ဖြစ်တဲ့ loop တစ်ခုကို run မယ် ပြီးရင် variable နှစ်ခုကိုယူပြီး ဘယ်ဘက် subtree ကို သိမ်းမယ်။

- ထို့နောက် while(k.left != null) ကို အသုံးပြု၍ ဘယ်ဘက်အခွဲ၏ ညာဖက်အစွန်းကို စစ်ဆေးမည်ဖြစ်ပြီး (k.right = root.right) ကို အသုံးပြု၍ အဆိုပါ node နှင့် ညာဖက်အခွဲနှင့် ချိတ်ဆက်ပေးမည်ဖြစ်သည်။

- ထို့နောက် root node ၏ ညာဘက်ညွှန်ပြချက်ကို ဘယ်ဘက်အခွဲ(root.right=left) ဖြင့် လင့်ခ်ချိတ်ပြီး root node ၏ ဘယ်ဘက်ညွှန်ပြချက်ကို null(root.left=null) အဖြစ် သတ်မှတ်ပြီး ( root = root.right ) ဖြင့် အပ်ဒိတ်လုပ်မည်ဖြစ်သောကြောင့် ယခု root သည် မှန်ကန်ပါသည်။ subtree node များ။

- ဘယ်ဘက်-သစ်ပင် အစိတ်အပိုင်းများအားလုံး ညာဘက်သစ်ပင်ဖြစ်လာသည်အထိ ဤလုပ်ငန်းစဉ်ကို ဆက်လက်လုပ်ဆောင်ပါမည်။ ထို့ကြောင့် ဒွိစုံပင်သည် ပြားသွားလိမ့်မည်။

 

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

ချိတ်ဆက်ထားသောစာရင်း LeetCode ဖြေရှင်းချက်သို့ Flatten Binary Tree

Python ဖြေရှင်းချက်-

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

Java ဖြေရှင်းချက်-

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)

အာကာသရှုပ်ထွေး: အို (1)

တစ်ကြိမ်သာ ဖြတ်ကျော်ပြီးသည်နှင့်အမျှ အချိန်၏ရှုပ်ထွေးမှုသည် o(n) ဖြစ်လိမ့်မည်။

အပိုနေရာမယူထားသောကြောင့်၊ space complexity သည် o(1) constant extra space ဖြစ်လိမ့်မည်။

အလားတူမေးခွန်း- https://www.tutorialcup.com/interview/linked-list/flattening-linked-list.htm

N-Ary Tree LeetCode ဖြေရှင်းချက်၏ အချင်း

ပြဿနာ ထုတ်ပြန်ချက်- N-Ary Tree LeetCode ဖြေရှင်းချက်၏ အချင်း- N-ary သစ်ပင်၏ အမြစ်ကို ပေး၍ သင်သည် သစ်ပင်၏ အချင်း၏ အရှည်ကို တွက်ချက်ရန် လိုအပ်သည်။ N-ary သစ်ပင်တစ်ပင်၏ အချင်းသည် သစ်ပင်ရှိ ဆုံမှတ်နှစ်ခုကြားရှိ အရှည်ဆုံးလမ်းကြောင်းဖြစ်သည်။ ဤလမ်းသည် ဖြစ်နိုင်သည်ဖြစ်စေ မရှိသည်ဖြစ်စေ...

ဆက်ဖတ်ရန်

Binary Tree Leetcode ဖြေရှင်းချက်၏ အနိမ့်ဆုံးဘုံဘိုးဘွား

Problem Statement The binary Tree ၏ အနိမ့်ဆုံးဘုံဘိုးဘေး LeetCode ဖြေရှင်းချက် – “Binary သစ်ပင်၏ အနိမ့်ဆုံးဘုံဘိုးဘေးများ” သည် ဒွိသစ်ပင်၏အမြစ်နှင့် သစ်ပင်၏ဆုံမှတ်နှစ်ခုကို ပေးဆောင်သည်ဟု ဖော်ပြထားသည်။ ဤ node နှစ်ခု၏ အနိမ့်ဆုံးဘုံဘိုးဘေးကို ရှာရန် လိုအပ်သည်။ အနိမ့်ဆုံးအဖြစ်များ…

ဆက်ဖတ်ရန်

Node Leetcode ဖြေရှင်းချက်တစ်ခုစီတွင် Next Right Pointers များဖြည့်ခြင်း။

ပြဿနာထုတ်ပြန်ချက် Node တစ်ခုစီရှိ LeetCode ဖြေရှင်းချက်တွင် မှန်ကန်သောညွှန်ကိန်းများဖြည့်ခြင်း - "Node တစ်ခုစီတွင် Next Right Pointers ကိုဖြည့်ခြင်း" သည် ပြီးပြည့်စုံသော binary tree ၏အမြစ်ကိုပေးဆောင်ပြီး ကျွန်ုပ်တို့သည် node ၏နောက်ထပ်ညွှန်ပြချက်တစ်ခုစီကို ၎င်း၏နောက်ညာဘက် node တွင်ထည့်သွင်းရန်လိုအပ်သည်။ နောက်တစ်ခုမရှိရင်…

ဆက်ဖတ်ရန်

Nodes များကိုဖျက်ပြီး Forest Leetcode ဖြေရှင်းချက်ကို ပြန်ပေးပါ။

ပြဿနာဖော်ပြချက် Node များကိုဖျက်ခြင်းနှင့် Return Forest LeetCode ဖြေရှင်းချက် - "Nodes များကိုဖျက်ပြီး Return Forest" သည် node တစ်ခုစီတွင် ကွဲပြားသောတန်ဖိုးရှိသည့် binary tree ၏အမြစ်ကို ပေးဆောင်သည်ဟုဖော်ပြထားသည်။ ကျွန်ုပ်တို့တွင်ပါရှိသောတန်ဖိုးများပါရှိသော node အားလုံးကိုဖျက်ရန်လိုအပ်သည့် array၊ to_delete ကိုလည်းပေးထားပါသည်။

ဆက်ဖတ်ရန်

Binary Search Tree Leetcode ဖြေရှင်းချက်ကို ပြန်လည်ရယူပါ။

ပြဿနာထုတ်ပြန်ချက် ပြန်လည်ရယူခြင်း Binary Search Tree LeetCode ဖြေရှင်းချက် – “Recover Binary Search Tree” သည် မှားယွင်းသော node နှစ်ခု၏တန်ဖိုးများကို အမှားဖြင့် လဲလှယ်လိုက်သော ဒွိရှာဖွေမှုသစ်ပင်၏ အမြစ်ကို ပေးဆောင်သည်ဟု ဖော်ပြထားသည်။ ကျွန်ုပ်တို့သည် ၎င်း၏ဖွဲ့စည်းပုံကို မပြောင်းလဲဘဲ သစ်ပင်ကို ပြန်လည်ရယူရန် လိုအပ်သည်။ ဥပမာ- ထည့်သွင်းမှု- root = [1,3,null,null,2] အထွက်- [3,1,null,null,2] ...

ဆက်ဖတ်ရန်

Symmetric Tree Leetcode ဖြေရှင်းချက်

ပြဿနာထုတ်ပြန်ချက် Symmetric Tree LeetCode ဖြေရှင်းချက် – “Symmetric Tree” သည် ဒွိသစ်ပင်၏အမြစ်ကိုပေးဆောင်ကြောင်းဖော်ပြထားပြီး ပေးထားသော ဒွိစုံသစ်ပင်သည် သူ့ဘာသာသူမှန်တစ်ချပ်ဟုတ်မဟုတ် (၎င်း၏အလယ်ဗဟိုပတ်ပတ်လည်တွင် အချိုးညီညီ) ရှိမရှိ စစ်ဆေးရန် လိုအပ်ပါသည်။ ဟုတ်ပါက၊ မဟုတ်ရင် အမှားကို အမှန်ပြန်ပေးရမှာ ဖြစ်ပါတယ်။ ဥပမာ-…

ဆက်ဖတ်ရန်

ပစ်မှတ်ပေါင်းလဒ် Leetcode Solutions နှင့်အတူ Leaf လမ်းကြောင်းကိုမှ Root

တစ် ဦး က binary သစ်ပင်နှင့်တစ်ခုကိန်းပေးထားသည်။ ကျွန်ုပ်တို့၏ရည်မှန်းချက်မှာသစ်ပင်တွင်အမြစ်မှသစ်ရွက်လမ်းကြောင်းရှိမရှိပြန်လာရန်ဖြစ်သည်။ ၎င်းသည် sum သည် target-K နှင့်ညီသည်။ လမ်းကြောင်း၏ပေါင်းလဒ်သည်၎င်းပေါ်တွင်တည်ရှိသော node အားလုံး၏ပေါင်းလဒ်ဖြစ်သည်။ ၂ /

ဆက်ဖတ်ရန်

Translate »