Learn Data Structure In Burmese

မှတ်ချက် – ဒီ Post သည် Draft Publish ဖြစ်သည်။ တစ်ချို့အပိုင်းများ ဘာသာပြန်ဖို့လိုအပ်နေသေးသည်။ ဖြစ်နိုင်ရင် Feedback ပေးစေချင်ပါတယ်။

ကျွန်တော်ဒီနေ့ပြောမယ့်အကြောင်းအရာတွေတော်တော်များများက itsy-bisty-data-structures ကနေကိုးကားဘာသာပြန်ပြီးတော့ရေးသားထားတာဖြစ်ပါတယ်။ English လို Study လုပ်ရတာအဆင်ပြေတဲ့သူအတွေအတွက် နဂိုမူရင်း repo ကိုသွားပြီး study လုပ်ဖို့တိုက်တွန်းလိုပါတယ်။

ကိုယ်တိုင် CS ကျောင်းဆင်းမဟုတ်တာကြောင့် Data Structure/Algorithm ဘက်မှာအားနည်းတယ်လို့ခံစားရတယ်။ နောက်တကယ်အလုပ်လုပ်တဲ့အခါမှာလည်း ဒါတွေသိတာမသိတာဘယ်လောက်အရေးပါလဲဆိုတာ သိလာတွေကြောင့်ရယ် သေချာလိုက်လုပ်ဖြစ်ရင်း ဒီ repo က အတိုဆုံးနှင့် နားလည်အလွယ်ဆုံးဖြစ်တာကြောင့် မြန်မာလိုလေးပါရှိရင်ကောင်းမယ်ဆိုပြီး စဥ်းစားမိလို့ဘာသာပြန်တာလိုလို ကိုးကားတာလိုလိုလုပ်ပြီးရေးဖို့စဉ်းစားဖြစ်ပြီး ရေးဖြစ်သွားတာပါ။

ကျွန်တော်တို့ Data Structure တွေကောင်းကောင်းမသိဘူးဆိုရင်… algorithm problem တွေ solve လုပ်တဲ့နေရာမှာအတော်သိသာတယ်။ ဥပမာ ကိုယ်သိတဲ့ data structure နှင့် solve လုပ်ဖို့အရမ်းခက်ခဲနေတာမျိုးပေါ့။

Data Structure တွေများများသိထားတော့ ပြဿနာတစ်ခုကိုဖြေရှင်းပြီဆိုလျှင် ကိုယ်သိတဲ့ data structure တွေကိုလိုအပ်တဲ့နေရာမှာလိုအပ်သလိုသုံးတော့ ကိုယ့်ကုဒ်ကမရှုပ်ထွေးနေတော့ဘူးပေါ့။ လွယ်လွယ်ကူကူဖြစ်နေတယ်ပေါ့။

အခုကျွန်တော်တို့ data structure တွေကိုလေ့လာဖို့ အသုံးများတဲ့ data structure တွေကို JavaScript သုံးပြီးကိုယ်တိုင် implement လုပ်ကြမယ်။ တစ်ခြား language နှင့်လုပ်မယ်ဆိုလည်း idea ကအတူတူပဲဖြစ်လို့ကိုယ်ကြိုက်တဲ့ Language နှင့် implement လုပ်နိုင်ပါတယ်။ ကျွန်တော်ကတော့ မူရင်း repo က JavaScript အတိုင်းပဲ ဘာသာပြန်ပါ့မယ် 😄။

Data structure ဆိုတာဘာလဲ

Wikipedia မှာတော့ Data Structure ဆိုတာ Data တွေကို Store (သိမ်းဆည်းဖို့) နှင့် efficiently access/modification လုပ်နိုင်တဲ့ Data Organization တစ်ခုဖြစ်တယ်လို့မှတ်သားရပါတယ် (ဘာသာပြန်တာမှားကောင်းမှားနိုင်လို့ ကိုယ်တိုင် Wikipedia မှာရှာဖွေဖတ်ရှုစေချင်ပါတယ်)။

ကျွန်တော်တို့ Data တွေကို နည်းမျိုးစုံနှင့်ဖော်ပြနိုင်တယ်။ ဒါပေမယ့် ဒီ data ကဘာလဲ အဲ့ဒါကိုဘယ်နေရာအတွက်သုံးမှာလဲပေါ်မူတည်ပြီးတော့ ဘယ်လို data structure ကိုအသုံးပြုမလဲဆိုတာကိုဆုံးဖြတ်ရပါမယ်။ Data Structure တွေမှာလည်း သူ့အားသာတဲ့အပိုင်း၊ အားနည်းတဲ့အပိုင်းရှိတာမို့လို့ ကိုယ်အသုံးပြုလိုတဲ့အပေါ်မူတည်ပြီးအသင့်တော်ဆုံး data structure ကိုယူသုံးရပါမယ်။

အဲဒီအားသာချက်၊ အားနည်းချက်တွေကိုနားလည်ဖို့ရာအတွက် algorithms အကြောင်းနည်းနည်းပြောလိုက်ရအောင်။

ALGORITHMS

ALGORITHMS

ပထမဆုံး Algorithm ဆိုတာဘာလဲက စမယ်။ Algorithm ဆိုတာ ဒါပြီးရင် ဒါလုပ် ဒါပြီးရင် ဒါလုပ်ဆိုတဲ့ sets of operations တွေကိုထွင်ပြီးခေါ်တာပါ 🤣။

Data structure နှင့် Algorithm တွေ ဘယ်လိုဆက်စပ်နေလဲဆိုလျှင် Data structure တွေကို algorithm တွေနှင့်တည်ဆောက်ထားတာဖြစ်ပြီးတော့ algorithm တွေကို data structure တွေနှင့် တည်ဆောက်ထားတာဖြစ်ပါတယ်။ (အပြန်အလှန်ပဲပေါ့ 😀)

ဘယ်လို Task တစ်ခုပေးလိုက်ပေးလိုက် အဲဒါကိုဖြေရှင်းဖို့ မြောက်များစွာသောနည်းတွေရှိပါတယ်။ လူတွေက ယေဘုယျအားဖြင့် (ပုံမှန်အသုံးလိုတဲ့) task တစ်ခုပေးလိုက်တယ်ဆိုလျှင် တစ်ယောက်တစ်မျိုးစီ အဲ့ task ကိုဖြေရှင်းဖို့နည်းတွေထွက်လာပါတယ်။

ဥပမာ၊ unsorted item တွေကို sort လုပ်ဖို့ရာအတွက် algorithms တွေက နည်းတာမဟုတ်ဘူး… အောက်က sorting algorithm တချို့ကို ကြည့်လိုက်ရအောင်…

Insertion Sort, Selection Sort, Merge Sort, Bubble Sort, Heap Sort,
Quick Sort, Shell Sort, Timsort, Bucket Sort, Radix Sort, ...

ဒီ sorting နည်းတွေထဲမှာဆိုလျှင် တချို့ algorithm တွေက တချို့ algorithm တွေထက် ပိုမြန်တယ်။ တချို့ algorithm က memory အသုံးပြုမှုနည်းတယ်။ တချို့ algorithm က လွယ်လွယ်ကူကူ implement လုပ်နိုင်တယ်။ တချို့က dataset နှင့် ပတ်သက်တဲ့ assumption ေပါ် အခြေခံထားတယ်။

ဒီ algorithm တွေမှာ တစ်ခုက တစ်ခုထက် တချို့အရာတွေမှာ ပိုကောင်းတယ်။ ဒါကြောင့် ဒီ algorithm တွေကို ကိုယ့်လိုအပ်ချက်ပေါ်မူတည်ပြီး ဘယ်ဟာကို သုံးရမလဲဆိုပြီး ဆုံးဖြတ်ဖို့ရာအတွက် အဲဒါတွေကို တိုင်းတာဖို့ နည်းတစ်ခုလိုတယ်။ Algorithm တွေရဲ့ ပျမ်းမျှနှင့် အဆိုးဆုံးအခြေအနေ စွမ်းဆောင်ရည်တွေကို တိုင်းတာဖို့ရာအတွက် “Big-O” လို့ခေါ်တဲ့ တိုင်းတာမှုကို သုံးတယ်။

အခု အောက်မှာ Big O Notation အကြောင်း နည်းနည်းထပ်ရှင်းပြမယ်…

BIG-O NOTATION

## Big-O Complexity Chart by http://bigocheatsheet.com/

Algorithm တစ်ခုနှင့်တစ်ခု ဘယ် algorithm ကပိုမြန်တယ်/ပိုနှေးတယ်ဆိုတာတွေကို ယေဘူယျအားဖြင့်တိုင်းတာဘဲ ဖြစ်ဖြစ် အချင်းချင်းဘယ်ဟာကတော့ပိုနှေးတယ်ပိုမြန်တယ်ဆိုတာပြီး Discuss လုပ်တဲ့နေရာမှာဘဲဖြစ်ဖြစ် Big-O Notation ကို ကျွန်တော်တို့အသုံးပြုကြတယ်။

Big-O ဆိုတာ သင်္ချာသင်္ကေတတစ်ခုပါဘဲ။ ဒါကို computer science မှာ algorithm တစ်ခုမှာ input (ပေးလိုက်တဲ့ number) (N) အရေအတွက်ပေါ်မူတည်ပြီး algorithms တွေရဲ့ အမျိုးအစားကို ခွဲခြားတဲ့နေရာမှာသုံးကြတယ်။

Big-O ကို ကျွန်တော်တို့ အဓိကသုံးတဲ့ တိုင်းတာမှုနှစ်ခုရှိတယ်… အဲ့ဒါကဘာတွေလဲဆိုလျှင် Time complexity နှင့် Space complexity ဖြစ်တယ်။ အောက်မှာအဲ့နှစ်ခုရဲ့ ဆိုလိုရင်းကို တစ်ချက်နည်းနည်းထပ်ပြောပြထားတယ်။

Time complexity ဆိုတာ algorithm မှာ ပေးလိုက်တဲ့ items ပေါ်မူတည်ပြီး operate လုပ်တဲ့အရေအတွက်ကိုတွက်တာကိုပြောတာဖြစ်တယ်။

Space complexity ဆိုတာ ပေးလိုက်တဲ့ items ပေါ်မူတည်ပြီး memory ဘယ်လောက်အသုံးပြုလဲဆိုပြီး တွက်တာကိုပြောတာဖြစ်တယ်။

ဘာလို့ Time complexity နှင့် Space complexity ကိုခွဲထားတာလဲဆိုလျှင် algorithm တွေက operate လုပ်တာနည်းပေမယ့် memory space အများကြီးယူနိုင်တယ် တစ်ခုနှင့်တစ်ခုမတူဘူး ဒါကြောင့်ကိုယ်လိုအပ်တဲ့နေရာမှာ ဒီနှစ်ခုထဲကတစ်ခုပိုကောင်းလျှင်ရတယ်ဆိုတာမျိုးတွေရှိလာလျှင် ရွေးချယ်နိုင်အောင်ကြောင့်ဖြစ်တယ်။

အောက်ဖော်ပြပါ table မှာ အသုံးများတဲ့ (common ဖြစ်တဲ့) Big-O တွေကို ကြည့်ကြည့်ရအောင်…

အခေါ်အဝေါ်သင်္ကေတအဆိုး/အကောင်း/အကြိုး/အကြောင်း
ConstantO(1)AWESOME!!
LogarithmicO(log N)GREAT!
LinearO(N)OKAY
LinearithmicO(N log N)UGH…
PolynomialO(N ^ 2)SHITTY
ExponentialO(2 ^ N)HORRIBLE
FactorialO(N!)WTF

အခုပြောနေတာတွေကိုထင်းကနဲလင်းကနဲမြင်သာအောင် Example ပေးကြည့်မယ်။ ကျွန်တော်တို့ (N) အရေအတွက်ရှိတဲ့ items တွေကိုထည့်လိုက်ရင်ဘယ်လောက်ကြာလဲဆိုတာကိုအောက်ဖော်ပြပါ table မှာတစ်ချက်ကြည့်လိုက်ရအောင်။

Big ON = 5N = 10N = 20N = 30
O(1)1111
O(log N)2.3219…3.32194.3219…4.9068…
O(N)5102030
O(N log N)11.609…33.219…84.638…147.204…
O(N ^ 2)25100400900
O(2 ^ N)3210241,048,5761,073,741,824
O(N!)1203,628,8002,432,902,0…265,252,859,812,191,058,636,308,480,000,000

အခုမြင်တဲ့အတိုင်းဘဲ data sets လေးနည်းနည်းလေးတောင်မှ extra works တွေဘယ်လောက်လုပ်ရလဲဆိုတာမြင်နိုင်ပါတယ်။

Data structure တွေကိုအသုံးပြုပြီး အဓိကလုပ်တဲ့ action လေးခုရှိပါတယ်။ ဘာတွေလည်းဆိုရင် Accessing, Searching, Inserting, နှင့် Deleting တို့ဘဲဖြစ်ပါတယ်။

နောက်ထပ်မှတ်သားထားရမှာက data structure တွေက တစ်ချို့ action တွေမှာကောင်းပြီးတော့တစ်ချို့ action တွေမှာဆိုးချင်ဆိုးမှာဆိုတာပါ။

Data structureAccessingSearchingInsertingDeleting
ArrayO(1)O(N)O(N)O(N)
Linked ListO(N)O(N)O(1)O(1)
Binary Search TreeO(log N)O(log N)O(log N)O(Log N)

ဒါမှမဟုတ်… ပိုမြင်သာအောင်အောက်က table ကိုတစ်ချက်ကြည့်လိုက်အောင်…

Data structureAccessingSearchingInsertingDeleting
ArrayAWESOME!!OKAYOKAYOKAY
Linked ListOKAYOKAYAWESOME!!AWESOME!!
Binary Search TreeGREAT!GREAT!GREAT!GREAT!

တစ်ချို့ actions တွေက different “average” performance နှင့် “worst-case scenario” performance ဆိုပြီးရှိပါတယ်။

Perfect data structure ဆိုတာမရှိပါဘူး။ Data Structure တွေကိုရွေးတဲ့အခါမှာ ကိုယ် Handle လုပ်နေရတဲ့ data နှင့် ကိုယ်ကဒီ Data ကိုဘယ်မှာအသုံးပြုမလဲပေါ်မူတည်ပြီးရွေးရပါတယ်။ ဒါကြောင့်မလို့ common data structures တွေကိုသိထားဖို့အရေးကြီးပါတယ်။ ဒါမှကိုယ်လိုအပ်တဲ့အခါ အဲ့ဒီ့ data structure ထဲကရွေးရမှာမလို့ဖြစ်ပါတယ်။

MEMORY

MEMORY

ကွန်ပျူတာ Memory ဆိုတာနည်းနည်းပျင်းစရာကောင်းပါတယ်၊ order slots တွေထဲမှာ information တွေသိမ်းထားနိုင်တဲ့နေရာတစ်ခုပါဘဲ။ ကိုယ်လိုချင်တဲ့ information တွေကိုရနိုင်ဖို့ memory address သိဖို့လိုပါတယ်။

Memory Chunk တစ်ခုကိုအောက်ဖော်ပြပါအတိုင်းဖြစ်တယ်လို့ယူဆလိုက်ရအောင်…

Value1001011010000100010110100010000111011011
Address0123456789

Programming language တွေမှာ 0 index နှင့်ဘာလို့စလဲဆိုပြီးစဥ်းစားပြီးအဖြေမရခဲ့ဘူးဆိုရင် အခုအဖြေရပါပြီ ဘာလို့လဲဆိုတော့ Memory ကအဲ့လိုအလုပ်လုပ်လို့ပါတဲ့။

LISTS

LISTS

Memory နှင့် data structure တစ်ခု raw interaction ဘယ်လိုအလုပ်လုပ်လဲဆိုတာ demonstrate လုပ်ဖို့ရာအတွက် List တစ်ခု implement လုပ်ပါ့မယ်။

A list is a representation of an ordered sequence of values where the same value may appear many times.

class List {

    /**
     * Memory အလွတ်တစ်ခုကို JS Array အနေဖြင့်အသုံးပြုပြီးတော့ List ရဲ့ length ကိုလည်း store လုပ်ထားမှာဖြစ်ပါတယ်။
     * 
     * မှတ်သားစရာက ကျွန်တော်တို့ length ကိုသတ်သတ်သိမ်းထားတာပါဘဲ။ ဘာလို့လဲဆိုရင် memory ကနေ Length ဖတ်လို့မရလို့ပါဘဲ။
     */

    constructor() {
        this.memory = [];
        this.length = 0;
    }

    /**
     * ကျွန်တော်တို့ List ကနေပြီးတော့ data တွေကို retrieve လုပ်ဖို့နည်းလိုပါလိမ့်မယ်
     * 
     * Address တွေကို Keep Track လုပ်တာဖြစ်တဲ့အတွက်ကြောင့်မလို့ Very fast memory access ရမှာဖြစ်ပါတယ်။
     * 
     * List ကို access လုပ်တာက constant O(1) - "AWESOMW!!"
     */

    get(address) {
        return this.memory[address];
    }

    /**
     * List က order ရှိတာကြောင့်မလို့ အစ၊ အလယ်၊ အဆုံးမှ data တွေကို insert လုပ်နိုင်ပါတယ်။
     * 
     * ကျွန်တော်တို့ရဲ့ implementation မှာတော့ values တွေရဲ့ adding/removing ကို အစ သို့မဟုတ်
     * အဆုံး ကို focus ထားမှာဖြစ်ပြီးတော့ အောက်ဖော်ပြပါ method လေးမျိုးကိုအသုံးပြုသွားမှာဖြစ်ပါတယ်။
     * 
     *  - Push    - Value တစ်ခုကိုနောက်ဆုံးမှ Add လုပ်တဲ့နေရာမှာ
     *  - Pop     - Value တစ်ခုကိုနောက်ဆုံးမှ Remove လုပ်တဲ့နေရာမှာ
     *  - Unshift - Value တစ်ခုကိုအစကနေထည့်တဲ့နေရာမှာ
     *  - Shift   - Value တစ်ခုကိုအစကနေ Remove လုပ်တဲ့နေရာမှာ
     */

    /**
     * Push ကအနေစလိုက်မယ်ဆိုရင် ကျွန်တော်တို့ value ကို list ရဲ့နောက်ဆုံးမှာထည့်လိုက်ရအောင်...
     * 
     * ကျွန်တော်တို့ List ရဲ့နောက်ဆုံးကို Item တစ်ခုထည့်တာက အတော်လေးရိုးရှင်းပါတယ်။ ကျွန်တော်တို့ 
     * လွယ်လွယ်ကူကူတွက်လို့ရတဲ့ length ကို store လုပ်တယ်။ Add the value and increment
     * the length ရှင်းရှင်းလေးပါဘဲ။
     * 
     * Item တစ်ခုကို Push လုပ်တာက constant O(1) - "AWESOME!!"
     */

    push(value) {
        this.memory[this.length] = value;
        this.length++;
    }

    /**
     * ဆက်လက်ပြီးတော့ implement လုပ်ရမှာကတော့ ကျွန်တော်တို့ List ထဲက items တွေကိုနောက်ဆုံးမှ 
     * pop လုပ်ဖို့ဘဲဖြစ်ပါတယ်။
     * 
     * push နှင့်အတော်လေးတူပါတယ်။ List နောက်ဆုံး Value ကနေပြီးတော့ 
     *
     * Item တစ်ခုကို နောက်ဆုံးမှ popping လုပ်တာက constant O(1) - "AWESOME!!"
     */

    pop() {
        // ကျွန်တော်တို့ list ထဲမှာဘာမှမရှိရင်ဘာမှမလုပ်ဘူးပေါ့...
        if(this.length === 0) return;

        // နောက်ဆုံး item ကိုယူမယ်, ဖျက်မယ် ပြီးရင် သိမ်းထားတဲ့ value ကို return ပြန်မယ်...
        let lastAddress = this.length - 1;
        let value = this.memory[lastAddress];
        delete this.memory[lastAddress];
        this.length--;

        // Value ကို return ပြန်လိုက်တော့ ဒီ Value ကိုသုံးချင်သုံးလို့ရတာပေါ့
        return value;
    }

    unshift(value) {
        let previous = value;
        for(let address = 0; address < this.length; address++) {
            let current = this.memory[address];
            this.memory[address] = previous;
            previous = current;
        }

        this.memory[this.length] = previous;
        this.length++;
    }

    shift() {
        if(this.length === 0) return;

        let value = this.memory[0]

        for(let address = 0; address < thisl.length -1; address) {
            this.memory[address] = this.memory[address + 1];
        }

        delete this.memory[this.lenth - 1];
        this.length--;

        return value;
    }   
}

ကျွန်တော်တို့တွေ့ခဲ့တဲ့အတိုင်းဘဲ Lists တွေက fast access နှင့် နောက်ဆုံး items တွေနှင့် deal တာကောင်းပါတယ်။ သို့ပေမယ့် နောက်ဆုံး items မဟုတ်တဲ့ Value တွေနှင့် deal လုပ်တဲ့နေရာမှာ အဲ့လောက်မကောင်းတာကိုတွေ့ရမှာပါ။ ကျွန်တော်တို့

HASH TABLES

HASH TABLES
class HashTable {

    constructor() {
        this.memory = [];
    }

    hashKey(key) {
        let hash = 0;
        for(let index = 0; index < key.length; index++) {
            let code = key.charCodeAt(index);
            hash = ((hash << 5) - hash) + code | 0;
        }
        return hash;
    }

    get(key) {
        let address = this.hashKey(key);
        return this.memory[address];
    }

    set(key, value) {
        let address = this.hashKey(key);
        this.memory[address] = value;
    }

    remove(key) {
        let address = this.hashKey(key);
        if(this.memory[address]) {
            delete this.memory[address];
        }
    }

}

STACKS

STACKS
class Stack {

    constructor() {
        this.list = [];
        this.length = 0;
    }

    push(value) {
        this.length++;
        this.list.push(value);
    }

    pop() {
        if(this.length === 0) return;

        this.length--;
        return this.list.pop();
    }

    peek() {
        // နောက်ဆုံး item ကို remove မလုပ်ဘဲ return ပြန်မယ်
        return this.list[this.length - 1];
    }
}

QUEUES

Queue
class Queue {

    /**
     * ကျွန်တော်တို့ queue က memory အစား JavaScript ရဲ့ array ကို list အဖြစ်အသုံးပြုထားပါတယ်။
     */

    constructor() {
        this.list = [];
        this.length = 0;
    }

    enqueue(value) {
        this.length++;
        this.list.push(value);
    }

    dequeue() {
        if(this.length === 0) return;

        this.length--;
        return this.list.shift();
    }

    peek() {
        return this.list[0]
    }
}

GRAPHS

GRAPHS
class Graph {

    constructor () {
        this.nodes = []'
    }

    addNode() {
        return this.nodes.push({
            value,
            lines: []
        });
    }

    find() {
        return this.nodes.find(node => {
            return node.value === value;
        });
    }

    addLine(startValue, endValue) {
        let startNode = this.find(startValue);
        let endNode = this.find(endValue);

        if(!startNode || !endNode) {
            throw new Error('Both nodes need to exist');
        }

        startNode.lines.push(endNode);
    }

}

LINKED LISTS

LinkedList
class LinkedList {

    constructor() {
        this.head = null;
        this.length = 0;
    }

    get(position) {
        if(position >= this.length) {
            throw new Error('Position outside of list range');
        }

        let current = this.head;

        for (let index = 0; index < position; index++) {
            current = crrent.next;
        }

        return current;
    }

    add(value, position) {
        let node = {
            value,
            next: null
        };

        if(position === 0) {
            node.next = this.head;
            this.head = node;
        } else {
            let prev = this.get(position - 1);
            let current = this.next;
            node.next = current;
            prev.next = node;
        }

        this.length++;
    }

    remove(position) {
        if(!this.head) {
            throw new Error('Removing from empty list')
        }

        if(position === 0) {
            this.head = this.head.next;
        } else {
            let prev = this.get(position - 1);
            prev.next = prev.next.next;
        }

        this.length--;
    }

}

TREES

TREES
class Tree {
    constructor() {
        this.root = null;
    }

    traverse(callback) {
        function walk(node) {
            callback(node);

            node.children.forEach(walk);
        }

        walk(this.root);
    }

    add(value, parentValue) {
        let newNode = {
            value,
            children: []
        };

        if(this.root === null) {
            this.root = newNode;
            return;
        }

        if(this.traverse(node => {
            if(node.value === parentValue) {
                node.children.push(newNode);
            }
        });
    }
}

BINARY SEARCH TREES

BINARY SEARCH TREES
class BinarySearchTree {
    constructor() {
        this.root = null;
    }

    contains(value) {
        let current = this.root;

        while (current) {
            if (value > current.value) {
                current = current.right;
            } else if(value < current.value) {
                current = current.left;
            } else {
                return true;
            }
        }

        return false;
    }

    add(value) {
        let node = {
            value: value,
            left: null,
            right: null
        };

        if(this.root === null) {
            this.root = node;
            return;
        }

        let current = this.root;

        while(true) {
            // If the value is greater than the current value we move to the right.
            if(value > current.value) {

                // If `right` does not exist, set it to our node, and stop travesing.
                if(!current.right) {
                    current.right = node;
                    break;
                }

                current = current.rigth;

                // If the value is less than the current.value we move to the left.
            } else if (value < current.value) {

                // If `left` does not exist, set it to our node, and stop traversing.
                if (!current.left) {
                    current.left = node;
                    break;
                }

                current = current.left;
            } else {
                break;
            }
        }
    }
}

နိဂုံး

YGNCode.com (ကြော်ငြာ)

ပထမဆုံး ကျွန်တော့်ဘာသာပြန်ကိုအဆုံးထိဖတ်ပေးလို့ကျေးဇူးတင်ပါတယ်။ Computer Science နှင့်ပါတ်သတ်တာတွေကို မြန်မာလိုလေ့လာချင်တယ်ဆိုရင် www.ygncode.com လာရောက်ဖတ်ရှုဖို့ဖိတ်ခေါ်ပါတယ်။ အခုလိုမြန်မာလိုဘာသာပြန်တွေတင်မက အင်တာဗျူးပြင်ဆင်ဖို့ Algorithms တွေအပြင် အသုံးဝင်တဲ့ Website တွေ YouTube တွေပါပြန်လည်မျှဝေပေးလျှက်ရှိပါတယ်။

ကျေးဇူးတင်ပါတယ်

ပထမဦးဆုံး original ရေးသားသူ @jamiebuilds ကိုအထူးကျေးဇူးတင်ပါတယ်။ နောက်ကျွန်တော့်ဒီဘာသာပြန်ကိုပါဝင်ကူညီအားဖြည့်ပေးသော ကိုလမင်းကို ကိုကျေးဇူးအထူးတင်ပါတယ်။

ဒီဘာသာပြန်ကိုဖတ်ရှုကြသော စာဖတ်သူများကိုလည်း အထူးကျေးဇူးတင်ပါတယ်။

Leave a Reply

Up Next:

Cloud Computing ဘာဘယ်လဲ

Cloud Computing ဘာဘယ်လဲ