Introduction to data structure and algorithm (Part 2)

Key components of a program

Algorithm အကြောင်းမပြောခင်မှာ program တခုမှာ ပါ၀င်တဲ့ basic components သုံးခုအကြောင်းပြောပြချင်ပါတယ်။ Program တခုမှာအခြေခံအားဖြင့် input, algorithm နဲ့ output ဆိုပြီး components သုံးခုပါ၀င်ပါတယ်။

Input

Algorithm တခုကို perform လုပ်ဖို့အတွက် အနည်းဆုံး input တမျိုးမျိုးလိုပါတယ်။ အဲ့ဒီ input တွေကို variables တွေ၊ data structures တွေထဲ store လုပ်ပါတယ်။ Input တွေဟာ pre-insert or user input ဆိုပြီးကွဲပြားနိုင်ပါတယ်။

Algorithm

Algorithm ကတော့ အပေါ်ကရှင်းပြခဲ့တဲ့အတိုင်းပါပဲ၊ problem တခုကို solve လုပ်ဖို့ ဒါမှမဟုတ် အလုပ်တခုပြီးမြောက်ဖို့ သတ်မှတ်ထားတဲ့ step-by-step set of rules တွေပဲဖြစ်ပါတယ်။

Output

Algorithm တခုကနေ ထွက်လာတဲ့ calculated results တွေကို output လို့ခေါ်ပါတယ်။ Algorithm နဲ့ input တွေပေါ်မူတည်ပြီး output အမျိုးမျိုးကွဲပြားနိုင်ပါတယ်။

‍

Key components of an algorithm

Algorithm တခုမှာ အခြေခံအားဖြင့် ဒါတွေပါ၀င်ပါတယ်။

Variable

User input ဒါမှမဟုတ် pre-insert လုပ်ထားတဲ့ input တွေ၊ resulted output တွေကို store လုပ်ဖို့ variables တွေကို သုံးပါတယ်။

Data Structure

Data တွေကို store လုပ်ဖို့ variables တွေနဲ့ပဲအမြဲမလုံလောက်ပါဘူး။ Data တွေကို organize လုပ်ဖို့နဲ့ ပိုပြီး efficient ဖြစ်ဖြစ် store လုပ်ဖို့ data structures တွေကိုအသုံးပြုပါတယ်။

Operation

Operation ဆိုတာ data တွေကိုအသုံးပြုပြီးလုပ်ဆောင်တဲ့ simple calculations တွေ၊ basic actions တွေကိုခေါ်ပါတယ်။ ဒီ operations တွေကို operators တွေ အသုံးပြုပြီးလုပ်ဆောင်ပါတယ်။Operators တွေအများကြီးရှိပါတယ်။ 𝗔𝗿𝗶𝘁𝗵𝗺𝗲𝘁𝗶𝗰 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (eg. +, -, *, /, ^, %, etc.), 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (eg. <, >, <=, >=, ==, !=, etc.), 𝗹𝗼𝗴𝗶𝗰𝗮𝗹 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (eg. &&, ||, etc.), 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿 (?), 𝘂𝗻𝗮𝗿𝘆 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (eg. -x, !y, etc.) စတာတွေကတော့ အသုံးအများဆုံး operators တွေပဲဖြစ်ပါတယ်။ Operators တွေကို သုံးချင်တိုင်းလဲသုံးလို့မရပါဘူး၊ သူ့ order နဲ့သူရှိပါတယ်။

Control Structure

Default အရဆို code တွေကို top to bottom and left to right direction နဲ့ execute လုပ်ပါတယ်။ ကျွန်တော်တို့ဟာ ဒီ flow ကိုပြောင်းချင်တဲ့ အခါမှာ control structures တွေကိုအသုံးပြုပါတယ်။ 𝗖𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝘀𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁𝘀 (eg. if else, switch case, etc.), 𝗥𝗲𝗽𝗲𝘁𝗶𝘁𝗶𝗼𝗻 𝘀𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁𝘀 (eg. for loop, while loop, do-while loop, etc.), 𝗝𝘂𝗺𝗽 𝘀𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁𝘀 (eg. break, continue, etc.) စတာတွေဟာ control structures တွေပဲဖြစ်ပါတယ်။ Recursive functions တွေနဲ့ iterate လုပ်လို့ရတာကြောင့် functions တွေကိုလဲ control structure တွေထဲကတခုလို့ သတ်မှတ်လို့ရပါတယ်။

Function

Function ဆိုတာ သင့်ရဲ့ program ထဲက mini program လေးတခုပါပဲ။ အပေါ်က ဖော်ပြခဲ့တဲ့ အရာတွေကိုအသုံးပြုပြီး function တခုတည်ဆောက်နိုင်ပါတယ်။ Functions တွေဟာ variables တွေကို parameters တွေအနေနဲ့ လက်ခံပြီး၊ output ကို return values အနေနဲ့ပြန်ထုတ်ပေးပါတယ်။ Return မပြန်ပဲ output direct ထုတ်ပေးတဲ့ functions တွေလဲရှိပါတယ်။ Functions တွေကိုအသုံးပြုခြင်းအားဖြင့် algorithm တခုဟာ ပိုပြီး readable ဖြစ်သလို၊ လိုအပ်တဲ့နေရာမှာ လိုသလိုခေါ်သုံးလို့ရတာကြောင့် efficient လဲဖြစ်ပါတယ်။

Error Handling

Algorithm တခုမှာ error handling ကလဲမရှိမဖြစ်အရေးပါပါတယ်။ Input တွေဟာ ကျွန်တော်တို့ခန့်မှန်းထားတဲ့အတိုင်းလာမှာမဟုတ်ပါဘူး။ ဒါကြောင့်မို့လို့ unexpected input တွေအတွက် check လုပ်တာတွေ၊ error message ပြန်ထုတ်ပေးတာတွေ စသည်ဖြင့် လိုအပ်ပါတယ်။

Testing and Debugging

အပေါ်ကအရာတွေအားလုံးလုပ်ပြီးသွားရင်တော့ ကိုယ်ရေးထားတဲ့ algorithm ဟာ output တွေမှန်မှန်ကန်ကန်ထုတ်ပေးရဲ့လား၊ error handling တွေသေချာလုပ်ရဲ့လား၊ ဘယ်နားမှာ error တွေရှိနေလဲ စသည်ဖြင့် testing သေချာလုပ်ပြီး၊ debug လုပ်ဖို့လိုပါတယ်။

Documentation

Testing and Debugging လဲလုပ်ပြီးသွားပြီဆိုရင်တော့ ကိုယ့် algorithm ကို publish မလုပ်ခင် နောက်ဆုံးအဆင့်အနေနဲ့ documentation ရေးဖို့လိုပါတယ်။ ဒါမှ ကိုယ့် algorithm ကိုအသုံးပြုမယ့် တခြား developer တွေက ဒီ algorithm ဘယ်လိုအလုပ်လုပ်လဲ နားလည်မှာဖြစ်ပြီး အသုံးပြုနိုင်မှာပါ။ ကိုယ့် algorithm ကို တခြားလူတွေအသုံးပြုဖို့ ရည်ရွယ်တယ်ဆိုရင် သူများတွေနားလည်အောင် documentation ရေးပေးဖို့လိုပါတယ်။ တခြားလူတွေကိုလဲ အသုံးပြုစေချင်တယ် documentation လဲပါမလာဘူးဆိုရင်တော့ အလကားပါပဲ။

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

‍

What is a good algorithm?

Algorithm ကောင်းတခုဖြစ်ဖို့ဆို ဒါတွေလိုအပ်ပါတယ်။

Correctness

Algorithm ကောင်းတခုဟာ သင့်တော်တဲ့ input တိုင်းအတွက် မှန်ကန်တဲ့ output ပြန်ထုတ်ပေးဖို့လိုပါတယ်။

Efficiency

Algorithm ကောင်းတခုဟာ efficient ဖြစ်ဖို့လိုပါတယ်။ Efficient ဖြစ်တယ်ဆိုတာ resources နည်းနည်းနဲ့ အလုပ်ပြီးမြောက်တာကို ဆိုလိုတာပါ။ Algorithm တခုအတွက်အဲ့ resources တွေဆိုတာ ကုန်သွားမယ့် အချိန်(time complexity) နဲ့ အသုံးပြုမယ့် memory (space complexity) တွေဖြစ်ပါတယ်။ Algorithm တခု efficient ဖြစ်မဖြစ်၊ Big O notation ကို အသုံးပြုပြီး time and space complexity ကို တွက်ချက်၍ သိနိုင်ပါတယ်။

Simplicity

Algorithm ကောင်းတခုဟာ simple ဖြစ်ပြီး easy-to-understand ဖြစ်ရပါမယ်။ ရိုးရှင်းတဲ့ algorithm တခုဟာ ကိုယ်ကိုတိုင်အတွက် maintenance လုပ်ဖို့လွယ်ရုံသာမက ကိုယ့် algorithm ကိုအသုံးပြုမယ့် တခြား developer တွေအတွက်လဲ ပိုပြီး အဆင်ပြေစေပါတယ်။

ဒီသုံးခုဟာ algorithm ကောင်းတခုဖြစ်ဖို့လိုအပ်တဲ့ အဓိက အချက်သုံးချက်ဖြစ်ပြီး၊ ဒါတွေအပြင် robustness, optimality, scalability, security စသည်ဖြင့် အများကြီးကျန်ရှိပါသေးတယ်။အပေါ်ကဖော်ပြခဲ့တဲ့အရာတွေအကုန်လုံးဟာ algorithm နဲ့ပတ်သက်တဲ့ အခြေခံသဘောတရားတွေပဲဖြစ်ပါတယ်။ Algorithm ဆိုတာ ဘာလဲ၊ algorithm တခုမှာဘာတွေပါ၀င်လဲ၊ algorithm တခုကို ဘာတွေနဲ့တည်ဆောက်ထားလဲ၊ algorithm ကောင်းတခုဖြစ်ဖို့ဘာတွေလိုအပ်လဲဆိုတာ အခြေခံလောက်တော့ နားလည်သွားမယ်ထင်ပါတယ်။ နောက်လာမယ့် Part 3 မှာတော့ Big O notation အကြောင်းနဲ့ Big O notation ကိုအသုံးပြုပြီး time and space complexity ကိုဘယ်လိုတွက်ရမလဲဆိုတာ ဖော်ပြပေးသွားပါမယ်။