C# - Shaker Sort Algorithm

Posted by ေတဇာလင္း Monday 8 January 2018 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး မဂၤလာပါ။ ဒီေန႔ေတာ့ က်ေနာ္တို႔ Visual Studio C# ကို အသံုးျပဳၿပီးေတာ့ Sorting Algorithms ေတြထဲက တစ္ခုျဖစ္တဲ့ Shaker Sort Algorithm အေၾကာင္း ေလးကို ေလ့လာၾကည့္မွာ ျဖစ္ပါတရ္ဗ်ာ။ Shaker Sort ရဲ႕ အလုပ္လုပ္သြားတဲ့ လုပ္ငန္းစဥ္ မူၾကမ္းကို ေအာက္ကပံုမွာ ေလ့လာႏိုင္ပါတရ္ဗ်ာ။
အလုပ္လုပ္သြားတဲ့ လုပ္ငန္းစဥ္ကိုေတာ့ အထက္ပါပံုကို ၾကည့္လိုက္တာနဲ႔ နားလည္ႏိုင္ၾကမွာပါ။ ပိုၿပီးနားလည္သြားေအာင္ က်ေနာ္ အနည္းငရ္ ရွင္းျပပါ့မရ္။ Shaker Sort Algorithm ရဲ႕ Step တစ္ခုမွာ အဆင့္(2)ဆင့္ခြဲၿပီး အလုပ္လုပ္ပါတရ္(အတြင္း loop ႏွစ္ခုကို ဆိုလိုတာပါ)။
ပထမအဆင့္မွာေတာ့ Unsorted Array ရဲ႕ ပထမ Index ကစၿပီး ေနာက္ဆံုး index အထိ loop ပါတ္ကာ Increase ျဖစ္သြားေသာ ကပ္လွ်က္ index ေတြနဲ႔ ႏႈိင္းယွဥ္ပါတယ္။ ႏိႈင္းယွဥ္တဲ့ေနရာမွာ ႏႈိင္းယွဥ္ခံ element က ငယ္ေနရင္ေတာ့ ေနရာခ်င္း ခ်ိန္းယူပါတယ္။ loop ဆံုးသြားတဲ့အခ်ိန္မွာေတာ့ Array/List ရဲ႕ ေနာက္ဆံုး index မွာ အႀကီးဆံုးကိန္း ေရာက္ေနပါလိမ့္မယ္။ ၿပီးရင္ေတာ့ ဒုတိယ loop ကိုဆက္သြားပါၿပီ။
ဒုတိယအဆင့္ကေတာ့ ပထမအဆင့္နဲ႔ ေျပာင္းျပန္ပါ။ Sort ျဖစ္ၿပီးသား ေနာက္ဆံုး index ကို ခ်န္ခဲ့ပါတယ္။ sort မျဖစ္ေသးေသာ last index ကစၿပီး Decrease ျဖစ္သြားကာ first index ျပန္ေရာက္သည္အထိ loop ပါတ္ကာ ကပ္လွ်က္ index ေတြနဲ႔ ႏႈိင္းယွဥ္ပါတယ္။ ႏိႈင္းယွဥ္တဲ့ေနရာမွာ ႏႈိင္းယွဥ္ခံ element က ႀကီးေနရင္ေတာ့ ေနရာခ်င္း ခ်ိန္းယူပါတယ္။ loop ဆံုးသြားတဲ့အခ်ိန္မွာေတာ့ Array/List ထဲက အငယ္ဆံုး ကိန္းဟာ first index ဆီေရာက္ေနပါလိမ့္မယ္ဗ်။

မွတ္ခ်က္။ Step တစ္ႀကိမ္ၿပီးတိုင္း Array/List ရဲ႕ အျမင့္ဆံုး Index နဲ႔ အနိမ့္ဆံုး index တို႔ဟာ Sorting စီၿပီး ျဖစ္ေနပါလိမ့္မယ္။
ဒီနည္းလမ္းအတိုင္း Step အားလံုး ဆံုးသည္အထိ အလုပ္ လုပ္ေစၿပီး Array/List ကို Sorting စီယူမွာျဖစ္ပါတယ္ဗ်။ အေပၚက ရွင္းလင္းခ်က္ မူၾကမ္းပံုကို ၾကည့္လုိက္ရင္ေတာ့ မိတ္ေဆြတို႔အေနနဲ႔ က်ေနာ့္ ဆိုလိုရင္းကို နားလည္ပါလိမ့္မယ္ဗ်။ ပိုၿပီး နားလည္သြားေအာင္ ေအာက္က C# Code အျပည့္အစံုေလးကို ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Static Target Sort Algorithm

Posted by ေတဇာလင္း Monday 1 January 2018 1 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ Static Target Sort ဆိုတဲ့ Sorting Algorithm ေလးတစ္ခုအေၾကာင္းကို ေလ့လာၾကည့္ပါမယ္။
ဒါကေတာ့ Static Target Sort ရဲ႕ Algorithm ပါ။
ဒီေကာင္ရဲ႕ အလုပ္ လုပ္ပံု Algorithm အတိုင္း ငယ္စဥ္ႀကီးလိုက္ ပံုစံနဲ႔ ရွင္းျပပါ့မယ္။
1. Array/List ရဲ႕ ပထမဆံုးအခန္းကို Target အျဖစ္ သတ္မွတ္ပါတယ္။
2. Loop ပါတ္ၿပီး Target နဲ႔ က်န္ Element ေတြကို တိုက္ဆိုင္ စစ္ေဆးပါတယ္။
3. က်ေနာ္တို႔ စစ္ေဆးေနတဲ့အခ်ိန္မွာ Array/List ရဲ႕ Element တစ္လံုးလံုးဟာ Target Element ထက္ ငယ္သြားၿပီဆိုတာနဲ႔ Target Element နဲ႔ စစ္ေဆးခံ Element တို႔ကို ေနရာခ်င္း ခ်ိန္းယူပါတယ္ (Target Array အခန္း ခ်ိန္းသြားျခင္း မဟုတ္ပါ)။
4. Upper Loop တစ္ႀကိမ္တိုင္းမွာ Target ဟာ Array အခန္းတစ္ခုကိုသာ ရည္ညႊန္းၿပီး ေနာက္တစ္ႀကိမ္ Loop ဆက္သြားတဲ့အခ်ိန္မွာေတာ့ Target++ ျဖစ္ၿပီး ေနာက္အခန္းကို ေျပာင္းသြားမွာျဖစ္ပါတယ္။
5. Upper Loop တစ္ႀကိမ္ၿပီးတိုင္း Array/List ရဲ႕ ထိပ္ဆံုး အခန္း (သို႔မဟုတ္) ထိပ္ဆံုး Element ဟာ Sorting စဥ္ၿပီးသား ျဖစ္ၿပီး Upper Loop ဆံုးသြားတဲ့အခ်ိန္မွာေတာ့ Array/List အားလံုးဟာ Sorting စဥ္ၿပီးသား ျဖစ္သြားပါလိမ့္မယ္ဗ်။ ေအာက္က ရွင္းလင္းခ်က္ ပံုမူၾကမ္းေလးကို ၾကည့္လိုက္ပါ။
မိတ္ေဆြတို႔အေနနဲ႔ အေပၚက ရွင္းလင္းခ်က္ပံုနဲ႔ Algorithm ကို ၾကည့္လိုက္မယ္ဆိုရင္ျဖင့္ Static Target Sort Algorithm ရဲ႕ အလုပ္ လုပ္သြားပံု ဆိုလိုရင္းကို နားလည္ႏိုင္လိမ့္မယ္လို႔ ထင္ပါတယ္ဗ်။
ကဲ… ေသခ်ာနားလည္သြားေအာင္ ေအာက္မွာ C# နဲ႔ေရးထားတဲ့ ကုဒ္အျပည့္အစံုေလးကို ေလ့လာၾကည့္ၾကစို႔ဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Gnome Sort

Posted by ေတဇာလင္း Monday 25 December 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ Gnome Sort ဆိုတဲ့ Sorting Algorithm ေလးတစ္ခုအေၾကာင္းကို ေလ့လာၾကည့္ပါမယ္။ Gnome Sort ကို Stupid Sort လို႔လည္း ေခၚၾကပါေသးတယ္ဗ်။ ဒီ Algorithm ကေတာ့ ဥယ်ာဥ္တစ္ခုအတြင္းမွာ ပန္းအိုးေတြကို အစီအစဥ္တက် စီယူတဲ့အေပၚ အေျခခံထားပါတယ္။
Gnome Sort Algorithm
အလုပ္ လုပ္သြားတဲ့ ပံုကေတာ့ Insertion Sort နဲ႔ Bubble Sort ကို ေပါင္းစပ္ အသံုးျပဳထားတာနဲ႔ အလားသ႑န္တူပါတယ္။ ဒီေကာင္က Sorting စီရာမွာ ကပ္လွ်က္ Element ႏွစ္လံုးကို ႏိႈင္းယွဥ္ပါတယ္။ ႏိႈင္းယွဥ္ခံ Element ႏွစ္ခုအတြင္း ျခားနားခ်က္ရွိသြားၿပီး တစ္နည္းအားျဖင့္ else(Condition) မွန္သြားၿပီ ဆိုရင္ေတာ့ Element ႏွစ္ခုကို ေနရာခ်ိန္းယူပါတယ္။ ေနာက္ၿပီး loop ကို else(Condition) မွားသည္အထိ backwards(i--) ျပန္သြားၿပီး left order Element ေတြနဲ႔ ျပန္ႏိႈင္းယွဥ္ ၾကည့္ပါတယ္ဗ်။ If(Condition) ျပန္မွန္တဲ့အခ်ိန္ေရာက္ရင္ေတာ့ Right order Element ေတြနဲ႔ တစ္ခါျပန္ႏႈိင္းယွဥ္ၿပီး Algorithm ကို ဆက္အလုပ္ လုပ္ပါတယ္ဗ်။ ဒီသေဘာတရားအတိုင္း Sorted List မျဖစ္မျခင္း Algorithm ကို ထပ္ခါတလဲလဲ အလုပ္ လုပ္ေစမွာ ျဖစ္ပါတယ္။ ငယ္စဥ္ႀကီးလိုက္အတြက္ Algorithm အလုပ္ လုပ္သြားပံုကို က်ေနာ္တို႔ ဥပမာေလးနဲ႔ ေလ့လာၾကည့္ပါ့မယ္။
နားလည္ႏိုင္ၾကလိမ့္မယ္လို႔ ထင္ပါတယ္ဗ်ာ။
Time Complexity :
ဒီ Algorithm ကေတာ့ Stupid Sort အမ်ိဳးအစားထဲမွာပါေပမဲ့ Sorting Method ေတြထဲမွာ Adaptive ျဖစ္ၿပီး သံုးသင့္တဲ့ ထဲမွာပါ၀င္ပါတယ္ဗ်။ Processing Time ၾကာတယ္/မၾကာဘူးကေတာ့ အသံုးျပဳမယ့္ Array/List အေပၚမွာ မူတည္ပါလိမ့္မယ္။ Algorithm ကိုက loop တစ္ခုအတြင္းမွာ increase and decrease ႏွစ္မ်ိဳးစလံုးကို သံုးထားတာကိုး။ ဒါေၾကာင့္ အသံုးျပဳမည့္ Array/List မွာ Sorted ျဖစ္ၿပီးသား Element ေတြ မ်ားမ်ား order ျဖစ္ေနရင္ Processing Time ျမန္မွာျဖစ္ၿပီး မဟုတ္ရင္ေတာ့ ၾကာႏိုင္ပါလိမ့္မယ္ဗ်။
ကဲ… ေသခ်ာနားလည္သြားေအာင္ ေအာက္မွာ C# နဲ႔ေရးထားတဲ့ ကုဒ္အျပည့္အစံုေလးကို ေလ့လာၾကည့္ၾကစို႔ဗ်ာ။
မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။

C# - Bogo Sort

Posted by ေတဇာလင္း Wednesday 20 December 2017 0 comments

မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမမ်ား အားလံုးပဲ မဂၤလာပါဗ်ာ။ က်ေနာ္တို႔ ဒီေန႔ Bogo Sort ဆိုတဲ့ Sorting Algorithm ေလးတစ္ခုအေၾကာင္းကို ေလ့လာၾကည့္ပါမယ္။ က်ေနာ့္ ေလ့က်င့္ခန္းေတြကေတာ့ စတင္ ေလ့လာသူမ်ားအတြက္သာ ရည္ရြယ္ပါတရ္။ ဒါေၾကာင့္ သိေနၿပီးသား သူမ်ားအေနနဲ႔ နားလည္ေပးၾကဖို႔နဲ႔ က်ေနာ္ရဲ႕ တင္ျပပံု မွားယြင္းတာမ်ားရွိခဲ့ရင္ ျပန္လည္ေထာက္ျပေပးႏိုင္ဖို႔ ေမွ်ာ္လင့္ပါတရ္ဗ်။
Bogo Sort ကိုေတာ့… ဆိုၿပီး အမ်ိဳးမ်ိဳး ေခၚေ၀ၚၾကပါတယ္။ ေခါင္းစဥ္ခြဲေတြကို ၾကည့္လိုက္တာနဲ႔တင္ Bogo Sort ရဲ႕ အက်ိဳးသက္ေရာက္မႈကို သိႏိုင္ပါလိမ့္မယ္။ ဒီေကာင္က အစီအစဥ္က်နစြာ အလုပ္,လုပ္ျခင္းမ်ိဳးမဟုတ္ဘဲ မ်က္ကန္းလမ္းေလွ်ာက္ ဆန္ေနပါတယ္။ Key Generator တစ္ခုက ခ်ေပးလိုက္တဲ့ ကိန္းစဥ္တန္းေပၚမူတည္ၿပီး Sorted List ျဖစ္/မျဖစ္ စစ္ပါတယ္။ Sorted List မျဖစ္မျခင္း ကိန္းစဥ္တန္းကို Key Generator ကိုျဖတ္ခိုင္းၿပီး ေနာက္တစ္ဖန္ Input အတြက္ ကိန္းစဥ္တန္းတစ္ခု Generate လုပ္ယူပါတယ္။ Sorted List ျဖစ္သြားမွသာ ရပ္တန္႔သြားမွာျဖစ္ပါတယ္။ Key Generator ကလည္း Random သေဘာ အလုပ္,လုပ္ေနတာျဖစ္တဲ့အတြက္ လက္ေတြ႔အရ အန္စာတုံးေခါက္ယူတာနဲ႔ ဆင္တူပါတယ္။
Pseudocode ကေတာ့ ရိုးရွင္းပါတယ္။ ေအာက္မွာ ေလ့လာၾကည့္လိုက္ပါ။ Pseudocode နဲ႔ Exmaple ကိုၾကည့္လိုက္ရင္ေတာ့ Bogo Sort ရဲ႕ အလုပ္ လုပ္သြားပံုကို အနည္းငယ္ နားလည္ႏိုင္လိမ့္မယ္ ထင္ပါတယ္။ အန္စာတံုး ဥပမာနဲ႔ ျပန္ေျပာရရင္ေတာ့… 1. Shuffle( ) function ထဲမွာ ကိန္းစဥ္တန္း အေရအတြက္အတိုင္း အန္စာေခါက္မယ္၊ ရလာတဲ့ ကိန္းေတြကို အစဥ္တိုင္း ခ်ေရးမယ္၊ ၿပီးရင္ေတာ့ Sorted( ) function ကို Sorted List ျဖစ္/မျဖစ္ အစစ္ေဆးခံနိုင္ရန္ ပို႔ေပး ရပါတယ္။ 2. Sorted( ) function ကေတာ့ Shuffle( ) function က Generate လုပ္ၿပီး ပို႔လာတဲ့ ကိန္းစဥ္တန္းကို Sorted List ျဖစ္/မျဖစ္ ကိန္းလံုး အခ်င္းခ်င္း ႏႈိင္းယွဥ္ၿပီး စစ္ေဆးပါတယ္။ Sorted List ျဖစ္တယ္ဆို ရင္ေတာ့ End ကိုခုန္ၿပီး Sorted List ကို ထုတ္ျပေပးပါတယ္။ Sorted List မျဖစ္ခဲ့ရင္ေတာ့ အဆင့္(၁)၊ Shuffle( ) function ကိုျပန္သြားေစၿပီး ေနာက္တစ္ႀကိမ္ Input အတြက္ ကိန္းစဥ္တန္းကို Generate ထပ္လုပ္ခုိင္းပါတယ္။ ဒီသေဘာတရားအတိုင္း Sorted List မျဖစ္မျခင္း Algorithm ကို ထပ္ခါတလဲလဲ အလုပ္ လုပ္ေစမွာ ျဖစ္ပါတယ္။ Time Complexity ကေတာ့ ေအာက္ပါအတိုင္းပါပဲဗ်ာ။ အလုပ္ လုပ္ေနမယ့္ Shuffling ကေတာ့ အကန္႔အသတ္မရွိ n အႀကိမ္ေျမာက္ထိ ျဖစ္ႏိုင္ပါတယ္။ ဒါေၾကာင့္ အသံုးျပဳသင့္တဲ့ Sorting Algorithm တစ္ခုေတာ့ မဟုတ္ပါဘူး။ အျခားေသာ Algorithm ေတြနဲ႔ ႏႈိင္းယွဥ္ ေဖာ္ျပဖို႔အတြက္ ပညာေရးဆိုင္ရာ နယ္ပယ္ေတြမွာ သီအိုရီအရ သိသင့္တဲ့ Sorting Method တစ္ခုလို႔ပဲ ေျပာပါ ရေစ။ မွတ္ခ်က္။ ။ ၆ မ်က္ႏွာပဲရွိတဲ့ အန္စာတံုးမွာေတာင္မွ မိမိလိုခ်င္တဲ့ ကိန္းတစ္ခုကို ရဖို႔ အႀကိမ္အေတာ္ ၾကာၾကာ ေခါက္ယူရတာျဖစ္တဲ့အတြက္ Bogo Sort ရဲ႕ ကိန္းစဥ္တန္းဟာလည္း မ်ားရင္ မ်ားသလို Shuffling အႀကိမ္အေရအတြက္ ပိုမ်ားႏိုင္ၿပီး Compile Time ပိုၾကာႏိုင္ပါတယ္။ ဒါေပသိ ကိန္းစဥ္တန္းကို Generator နဲ႔ ထုတ္ေပးေနတာျဖစ္လို႔ ကံအေၾကာင္း သင့္ခဲ့ရင္ေတာ့ Sorted List ကို Shuffling အႀကိမ္ အနည္းငယ္အတြင္း မွာလည္း ရႏိုင္ပါတယ္ဗ်။
ေအာက္မွာ C# Code အျပည့္အစံုေလးကို ပိုနားလည္သြားေအာင္ ေလ့လာၾကည့္လိုက္ၾကပါအံုးဗ်ာ။ မိတ္ေဆြ၊ ညီအစ္ကို၊ ေမာင္ႏွမအားလံုး ေလ့လာျခင္းျဖင့္ ေက်နပ္ႏိုင္ၾကပါေစ။