អត្ថបទពិភាក្សាអំពីក្បួនដោះស្រាយការតម្រៀបដ៏ពេញនិយមបំផុតមួយចំនួនសម្រាប់អារេ ដែលប្រើទាំងការអនុវត្ត និងសម្រាប់គោលបំណងអប់រំ។ ខ្ញុំចង់ធ្វើការកក់ទុកភ្លាមៗថា រាល់ក្បួនដោះស្រាយដែលបានពិចារណាគឺយឺតជាងវិធីសាស្ត្របុរាណក្នុងការតម្រៀបអារេតាមបញ្ជីតម្លៃ ប៉ុន្តែយ៉ាងណាក៏ដោយ ពួកគេសមនឹងទទួលបានការយកចិត្តទុកដាក់។ មានអត្ថបទច្រើន ដូច្នេះសម្រាប់ក្បួនដោះស្រាយនីមួយៗ ខ្ញុំពិពណ៌នាអំពីមូលដ្ឋានបំផុត។
1. ក្បួនដោះស្រាយ "តម្រៀបតាមជម្រើស" ។
វាគឺជាក្បួនដោះស្រាយការតម្រៀបអារេដ៏សាមញ្ញបំផុតមួយ។ គំនិតគឺត្រូវឆ្លងកាត់អារេ ហើយរាល់ពេលរកមើលធាតុអប្បបរមានៃអារេ ដោយផ្លាស់ប្តូរវាជាមួយធាតុចាប់ផ្តើមនៃផ្នែកដែលមិនបានតម្រៀបនៃអារេ។ នៅលើអារេតូច វាអាចមានប្រសិទ្ធភាពជាងក្បួនដោះស្រាយការតម្រៀបដ៏ស្មុគស្មាញ ប៉ុន្តែក្នុងករណីណាក៏ដោយ វាបាត់បង់លើអារេធំ។ ចំនួននៃការផ្លាស់ប្តូរធាតុធៀបនឹងក្បួនដោះស្រាយ "ពពុះ" គឺ N/2 ដែល N ជាចំនួនធាតុអារេ។
ក្បួនដោះស្រាយ៖
1. ស្វែងរកធាតុអប្បបរមានៅក្នុងអារេ។
2. ប្តូរធាតុអប្បបរមា និងដំបូង។
3. ជាថ្មីម្តងទៀតយើងរកមើលធាតុអប្បបរមានៅក្នុងផ្នែកដែលមិនបានតម្រៀបនៃអារេ
4. ប្តូរធាតុទីពីរនៃអារេ និងអប្បបរមាដែលបានរកឃើញ ពីព្រោះធាតុទីមួយនៃអារេគឺជាផ្នែកដែលបានតម្រៀប។
5. យើងរកមើលតម្លៃអប្បបរមា និងធាតុ swap រហូតដល់អារេត្រូវបានតម្រៀបដល់ទីបញ្ចប់។
// តម្រៀបតាមជម្រើស (--- មុខងារតម្រៀបតាមជម្រើស(អារេតម្លៃ) អប្បបរមា = 0; សម្រាប់ i = 0 ដោយ Array.VBoundary() រង្វិលជុំ Min = i; សម្រាប់ j = i + 1 ដោយ Array.VBoundary() រង្វិលជុំ / /រកមើលធាតុអប្បបរមានៅក្នុងអារេ ប្រសិនបើអារេ[j]< Массив[Мин] Тогда Мин = j; КонецЕсли; КонецЦикла; Если Массив [Мин] = Массив [i] Тогда //Если мин. элемент массива = первому элементу неотс. части массива, то пропускаем. Продолжить; КонецЕсли; Смена = Массив[i]; //Производим замену элементов массива. Массив[i] = Массив[Мин]; Массив[Мин] = Смена; КонецЦикла; Возврат Массив; КонецФункции
2. ក្បួនដោះស្រាយ "តម្រៀបពពុះ" ។
ប្រហែលជាក្បួនដោះស្រាយដ៏ល្បីល្បាញបំផុតដែលប្រើសម្រាប់គោលបំណងអប់រំគឺយឺតពេកសម្រាប់ការប្រើប្រាស់ជាក់ស្តែង។ ក្បួនដោះស្រាយមានមូលដ្ឋានលើក្បួនដោះស្រាយស្មុគស្មាញជាងនេះ៖ "តម្រៀប Shaker", "តម្រៀបពីរ៉ាមីត", "តម្រៀបរហ័ស" ។ គួរកត់សម្គាល់ថា ក្បួនដោះស្រាយលឿនបំផុតមួយ “Fast Algorithm” ត្រូវបានបង្កើតឡើងដោយការធ្វើឱ្យប្រសើរឡើងនូវក្បួនដោះស្រាយដ៏អាក្រក់បំផុតមួយប្រភេទ “Bubble Sort” “Quick” និង “Shaker” នឹងត្រូវបានពិភាក្សាបន្ថែមទៀត។ អត្ថន័យនៃក្បួនដោះស្រាយគឺថាធាតុ "ស្រាលបំផុត" នៃអារេ "អណ្តែត" និង "ធ្ងន់បំផុត" "លិច" ។ ដូច្នេះឈ្មោះ "Bubble Sort"
ក្បួនដោះស្រាយ៖
1. ធាតុនីមួយៗនៃអារេត្រូវបានប្រៀបធៀបជាមួយនឹងធាតុបន្ទាប់ ហើយប្រសិនបើធាតុ [i] > ធាតុត្រូវបានជំនួស។ ដូច្នេះធាតុ "ស្រាលបំផុត" "អណ្តែត" - ផ្លាស់ទីទៅដើមបញ្ជីហើយ "លិច" ធ្ងន់បំផុត - ផ្លាស់ទីទៅទីបញ្ចប់។
2. ធ្វើម្តងទៀតជំហានទី 1 n-1 ដង ដែល n ជា Array.Quantity () ។
//Bubble Sort (--- Function Bubble Sort(Value Array) For i = 0 By Array.InBorder() Loop For j = 0 By Array.InBorder() - i - 1 Loop ប្រសិនបើ Array[j] > Array បន្ទាប់មកជំនួស = អារេ[j];
3. Algorithm "Shaker sort" (Shuffle sort, Bidirectional bubble sort)។
ក្បួនដោះស្រាយគឺជាកំណែនៃប្រភេទមុន - "តម្រៀបពពុះ" ។ ភាពខុសគ្នាចំបងគឺថា នៅក្នុងការតម្រៀបពពុះបុរាណមានចលនា unidirectional នៃធាតុពីបាតទៅកំពូល ខណៈពេលដែលនៅក្នុង shaker តម្រៀបចលនាដំបូងកើតឡើងពីបាតទៅកំពូល ហើយបន្ទាប់មកពីកំពូលទៅបាត។
ក្បួនដោះស្រាយគឺដូចគ្នានឹងការតម្រៀបពពុះ + វដ្តពីលើចុះក្រោមត្រូវបានបន្ថែម។
នៅក្នុងឧទាហរណ៍ខាងក្រោម មានភាពប្រសើរឡើងចំពោះការតម្រៀបទឹកក្រឡុក។ មិនដូចបុរាណទេ ការប្រើពាក្យដដែលៗតិចជាង 2 ដង។
// តម្រៀបដោយការលាយ (Shaker-Sort) (--- Function Sort by Mixing (Value Array) For i = 0 PO Array.VBoundary()/2 Loop nIter = 0; conIter = Array.VBoundary(); while nIter Array [nIter+ 1] បន្ទាប់មក ការជំនួស = អារេ[nIter]; អារេ[nIter] = អារេ[nIter + 1] = ការជំនួស; > Array[conIter] បន្ទាប់មក Replacement = Array[conIter - 1];
4. ក្បួនដោះស្រាយ "ការតម្រៀបមនុស្សតឿ" ។
ក្បួនដោះស្រាយត្រូវបានគេដាក់ឈ្មោះយ៉ាងចម្លែកដោយសារអ្នកវិទ្យាសាស្ត្រហូឡង់ លោក Dick Grun។
ការតម្រៀប Gnome គឺផ្អែកលើបច្ចេកទេសដែលប្រើដោយ gnome សួនជនជាតិហូឡង់ទូទៅ (ហូឡង់ tuinkabouter) ។ នេះគឺជាវិធីសាស្រ្តដែល gnome សួនច្បារតម្រៀបជួរនៃផើងផ្កា។ សំខាន់គាត់សម្លឹងមើលផើងសួនបន្ទាប់ និងពីមុន៖ ប្រសិនបើពួកវាស្ថិតក្នុងលំដាប់ត្រឹមត្រូវ គាត់បោះផើងមួយទៅមុខ បើមិនដូច្នេះទេ គាត់ប្តូរវា ហើយបោះមួយត្រឡប់។ លក្ខខណ្ឌព្រំដែន៖ ប្រសិនបើមិនមានសក្តានុពលពីមុនទេ វាបោះជំហានទៅមុខ។ បើមិនមានឆ្នាំងក្រោយទេវាចប់ហើយ។
លោក Dick Grun
នោះគឺជាការពិពណ៌នាទាំងមូលនៃក្បួនដោះស្រាយ "ការតម្រៀបមនុស្សតឿ"។ គួរឱ្យចាប់អារម្មណ៍ ក្បួនដោះស្រាយមិនមានរង្វិលជុំជាប់គ្នាទេ ប៉ុន្តែតម្រៀបអារេទាំងមូលក្នុងមួយវគ្គ។
// ការតម្រៀប Dwarven (--- Function DwarvenSort(Value Array) i = 1; j = 2; while i< Массив.Количество() Цикл // Сравнение < - Сортировка по возрастанию, >- ចុះបើ Array i = j;
j = j + 1;
ការជំនួសផ្សេងទៀត = អារេ[i];
អារេ[i] = អារេ;
អារេ = ជំនួស;
i = ខ្ញុំ - 1;
ប្រសិនបើ i = 0 បន្ទាប់មក i = j;
j = j + 1;
បញ្ចប់ប្រសិនបើ;< Массив Цикл Массив[j] = Массив; Замена = j - 1; Ключ = j - 1; j = j - 1; КонецЦикла; Массив[Ключ] = Замена; КонецЦикла; Возврат Массив; КонецФункции //---}
បញ្ចប់ប្រសិនបើ;
វដ្តបញ្ចប់;
ត្រឡប់អារេ; មុខងារបញ្ចប់ //---)
5. ក្បួនដោះស្រាយ "ការតម្រៀបបញ្ចូល" ។
នេះជាក្បួនតម្រៀបសាមញ្ញ។ ចំនុចនោះគឺថានៅជំហាននីមួយៗ យើងយកធាតុមួយ រកមើលទីតាំងសម្រាប់វា ហើយបញ្ចូលវាទៅក្នុងកន្លែងដែលត្រឹមត្រូវ។< ТочкаРазрыв Тогда лМассив.Добавить(Массив[Сч]); Иначе прМассив.Добавить(Массив[Сч]); КонецЕсли; КонецЦикла; Возврат Слияние(СортировкаСлиянием(лМассив),СортировкаСлиянием(прМассив)); КонецФункции Функция Слияние(массив1,массив2) a = 0; b = 0; слМассив = Новый Массив; Для Сч = 0 ПО (Массив1.Количество() + Массив2.Количество())-1 Цикл слМассив.Добавить(); КонецЦикла; Для i = 0 ПО (массив1.Количество() + массив2.Количество())-1 Цикл Если b < массив2.Количество() И a < массив1.Количество() Тогда Если (массив1[a] >ឧទាហរណ៍បឋម៖ ពេលលេងមនុស្សល្ងីល្ងើ អ្នកគូរសន្លឹកបៀមួយសន្លឹកពីបាត ហើយបញ្ចូលវាទៅក្នុងកន្លែងដែលសមស្របតាមលំដាប់ឡើងក្នុងសន្លឹកបៀដែលអ្នកមាន។ ឬ< массив2.Количество()) Тогда слМассив[i] = массив2[b]; b = b + 1; Иначе слМассив[i] = массив1[a]; a = a + 1; КонецЕсли; Иначе Если b < массив2.количество() Тогда слМассив[i] = массив2[b]; b = b + 1; Иначе слМассив[i] = массив1[a]; a = a + 1; КонецЕсли; КонецЕсли; КонецЦикла; Возврат слМассив; КонецФункции //---}
នៅក្នុងហាងដែលពួកគេបានផ្តល់ឱ្យអ្នកនូវការផ្លាស់ប្តូរសម្រាប់ 550 rubles - វិក័យប័ត្រមួយគឺ 500, ផ្សេងទៀតគឺ 50 ។ អ្នកមើលទៅក្នុងកាបូបរបស់អ្នកហើយមានវិក័យប័ត្រនៅក្នុងនិកាយចំនួន 10,100,1000 ។ អ្នកបញ្ចូលវិក័យប័ត្រ
ក្បួនដោះស្រាយត្រូវបានដាក់ឈ្មោះតាមអ្នកវិទ្យាសាស្ត្រអាមេរិក Donald Schell ។ នៅស្នូលរបស់វា ក្បួនដោះស្រាយនេះគឺជាក្បួនដោះស្រាយការដាក់បញ្ចូលដែលប្រសើរឡើង។ ចំណុចនៃក្បួនដោះស្រាយគឺដើម្បីប្រៀបធៀបមិនត្រឹមតែធាតុដែលមានទីតាំងនៅជាប់គ្នាប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងនៅចម្ងាយមួយចំនួនផងដែរ។ ទីមួយ ជំហានមួយត្រូវបានជ្រើសរើស - ចន្លោះពេលជាក់លាក់មួយ ដែលធាតុអារេនឹងត្រូវបានប្រៀបធៀបនៅពេលធ្វើម្តងទៀតនីមួយៗ។ ជាធម្មតាវាត្រូវបានកំណត់ដូចនេះ៖
សម្រាប់ការធ្វើឡើងវិញដំបូង ជំហាន = Object(Array.Quantity()/2) សម្រាប់ការធ្វើឡើងវិញជាបន្តបន្ទាប់ Step = Object(ជំហាន/2)។ ទាំងនោះ។ ជំហានត្រូវបានកាត់បន្ថយបន្តិចម្តងៗ ហើយនៅពេលដែលជំហានស្មើនឹង 1 ការប្រៀបធៀបចុងក្រោយនឹងកើតឡើង ហើយអារេនឹងត្រូវបានតម្រៀប។
ឧទាហរណ៍៖
បានផ្តល់អារេ (10,5,3,1,14,2,7,12) ។
1. ជំហាន = 4 ។
យើងតម្រៀបតាមសិលាចារឹកសាមញ្ញជារៀងរាល់ 4 ក្រុមនៃធាតុ 2 (10,14)(5,2)(3,7)(1,12)
10 ,2 ,3 ,1,14 ,5 ,7 ,12
2. ជំហាន = 2
យើងតម្រៀបតាមសិលាចារឹកសាមញ្ញជារៀងរាល់ 2 ក្រុមនៃ 4 ធាតុ (10,3,14,7)(2,1,5,12)
3 ,1 ,7 ,2 ,10 ,5 ,14 ,12
3. ជំហាន = 1
យើងតម្រៀបតាមសិលាចារឹកសាមញ្ញនីមួយៗ 1 ក្រុមនៃ 8 ធាតុ។
1,2,3,5,7,10,12,14
// Shell Sort (--- Function Shell Sort(Value Array) Step = Integer(Array.Quantity()/2); while Step > 0 Cycle i = 0; while i< (Массив.Количество() - Шаг) Цикл j = i; Пока j >= 0 AND Array[j] > Array Loop Replacement = Array[j];
អារេ[j] = អារេ;
អារេ = ជំនួស;
j = j − 1;
ប្រសិនបើ ApplyDisplaySortThenDisplaySortChart(Array);< m Цикл i = i + 1; КонецЦикла; Пока Массив[j] >បញ្ចប់ប្រសិនបើ;< j Тогда б_Сортировка(Массив,НижнийПредел,j); КонецЕсли; Если i < ВерхнийПредел Тогда б_Сортировка(Массив,i,ВерхнийПредел); КонецЕсли; КонецПроцедуры Функция БыстраяСортировка(Массив) НижняяГраница = 0; ВерхняяГраница = Массив.ВГраница(); б_Сортировка(Массив,НижняяГраница,ВерхняяГраница); Возврат Массив; КонецФункции //---}
វដ្តបញ្ចប់;
i = i + 1;
//Sort by a list of values (--- Function Sort by a List of Values (អារេតម្លៃ) mListValues = New ListValues; mListValues.LoadValues(Array); mListValues.SortByValue(SortDirection.Asc); ត្រឡប់ mListValues.UnloadValues(); EndFunction //---)
ការតម្រៀបទាំងអស់អាចត្រូវបានបង្កើនល្បឿនដោយការដាក់លេខកូដនៅក្នុងរង្វិលជុំ 1 ជួរ។ ប៉ុន្តែសម្រាប់ការអានបាន ខ្ញុំទុកវាបែបហ្នឹង។
ខ្ញុំបានសរសេរដំណើរការដែលអនុវត្តក្បួនដោះស្រាយខាងលើទាំងអស់ ហើយក៏គាំទ្រចលនាថាមវន្តនៃដំណើរការតម្រៀបផងដែរ។ (លើកលែងតែការតម្រៀបស្តង់ដារ 1c) .
-នៅពេលដំណើរការចាប់ផ្តើម អារេនៃលេខចៃដន្យពី 0 ដល់ 100 ដែលមានវិមាត្រនៃធាតុ 100 ត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិ។
-ដើម្បីបង្កើតអារេផ្សេងទៀត អ្នកត្រូវតែចុចលើប៊ូតុង "បង្កើតអារេ RNG" អ្នកក៏អាចជ្រើសរើសជួរដែលត្រូវការផងដែរ។
- ដើម្បីបើកចលនាថាមវន្ត អ្នកត្រូវតែធីកប្រអប់ "ការតម្រៀបបង្ហាញក្នុងគំនូសតាង"។ ខ្ញុំណែនាំអ្នកឱ្យធីកប្រអប់សម្រាប់ក្បួនដោះស្រាយដែលគ្មានប្រសិទ្ធភាព នៅពេលដែលទំហំអារេឡើងដល់ 100 ធាតុ បើមិនដូច្នេះទេ អ្នកនឹងចាស់ពេកក្នុងការរង់ចាំការតម្រៀប :)
ការបង្ហាញថាមវន្តនៃដំណើរការតម្រៀបកាត់បន្ថយដំណើរការយ៉ាងខ្លាំង ប៉ុន្តែអ្នកអាចមើលឃើញយ៉ាងច្បាស់ពីរបៀបដែលក្បួនដោះស្រាយដំណើរការ។
មិនយូរមិនឆាប់ អ្នកសរសេរកម្មវិធីណាមួយនឹងត្រូវតម្រៀបទិន្នន័យពីអារេមួយ។ ថាតើវាកំពុងបង្ហាញទិន្នន័យពីមូលដ្ឋានទិន្នន័យតាមលំដាប់អក្ខរក្រម ឬតម្រៀបឈ្មោះឯកសារតាមកាលបរិច្ឆេទដែលបានកែប្រែចុងក្រោយ វាអាចត្រូវបានធ្វើដោយអរគុណចំពោះមុខងារ PHP ដែលមានស្រាប់សម្រាប់តម្រៀបទិន្នន័យអារេ។ នៅក្នុងអត្ថបទនេះ ខ្ញុំនឹងបង្ហាញ និងពន្យល់ជាមួយឧទាហរណ៍ពីរបៀបដែលមុខងារដូចជា sort(), rsort() ដំណើរការ។
មុខងារ; - តម្រៀបអារេតាមលំដាប់ឡើង និងតាមលំដាប់អក្ខរក្រម
រចនាសម្ព័ន្ធ៖
($អារេ, $Flag);
មុខងារតម្រៀបអារេដែលបានផ្តល់ឱ្យវា $Array តាមលំដាប់ឡើង។ មុខងារត្រូវបានរចនាឡើងដើម្បីធ្វើការជាមួយបញ្ជី។ បញ្ជីគឺជាអារេធម្មតាដែលគ្រាប់ចុចចាប់ផ្តើមពីសូន្យ។ មុខងារអាចត្រូវបានផ្តល់ជាអាគុយម៉ង់ជាជម្រើស $Flag ដែលរៀបចំយ៉ាងពិតប្រាកដនូវអ្វីដែលគួរកើតឡើង ការតម្រៀប. ពិចារណាការពិពណ៌នានៃអាគុយម៉ង់ $Flag៖
SORT_REGULAR- មុខងារតម្រៀបលំនាំដើម
SORT_NUMERIC- លេខតម្រៀបឡើង
SORT_STRING- តម្រៀបខ្សែអក្សរតាមអក្ខរក្រម
សូមពិចារណាឧទាហរណ៍មួយ៖ យើងមានអារេដែលទិន្នន័យអំពីចំនួនគូសិស្សក្នុងឆ្នាំសិក្សាផ្សេងៗគ្នាត្រូវបានរក្សាទុកក្នុងទម្រង់វឹកវរ។
";) ?> លទ្ធផលនៃអក្សរសិល្ប៍៖ វគ្គសិក្សា៖ ១ - ៧២ គូ វគ្គ៖ ២ - ៨៣ គូ វគ្គ៖ ៣ - ១០០ គូ ប្រសិនបើយើងមិនបានអនុវត្តមុខងារទេ លទ្ធផលនៃការងារនឹងមានដូចខាងក្រោម៖ វគ្គសិក្សា៖ ១ - 83 គូវគ្គសិក្សា: 2 - 100 គូវគ្គសិក្សា: 3 - 72 គូ
តម្រៀបតាមអក្ខរក្រម
ខាងក្រោមគឺជាស្គ្រីបដែលតម្រៀបប្រទេសនៃអារេរបស់ពួកគេតាមអក្ខរក្រម អាគុយម៉ង់ទីពីរនៃអនុគមន៍ ($Flag) មិនចាំបាច់កំណត់ទេ ពីព្រោះ មុខងារខ្លួនវានឹងយល់ថាវាត្រូវធ្វើការជាមួយខ្សែអក្សរ។
";) ?> លទ្ធផលការងារ៖ អាមេនី អ៊ីតាលី រុស្ស៊ី ជប៉ុន
មុខងារ rsort() - តម្រៀបអារេតាមលំដាប់ចុះ
មុខងារនេះគឺមិនសមហេតុផល ប៉ុន្តែតម្រៀបអារេតាមលំដាប់ចុះ។ តោះមើលរចនាសម្ព័ន្ធវាក្យសម្ព័ន្ធ៖
($អារេ, $Flag);
ឧទាហរណ៍សម្រាប់មុខងារនេះនឹងស្រដៀងទៅនឹងឧទាហរណ៍ដែលបានផ្តល់ឱ្យខាងលើ លើកលែងតែរឿងមួយ ទិន្នន័យពីអារេនឹងត្រូវបានតម្រៀបតាមលំដាប់ចុះ។ យើងកំពុងបង្កើតអារេនៃរង្វាន់សម្រាប់អ្នកដែលទទួលបានចំណាត់ថ្នាក់លេខ 1 ទី 2 និងទី 3 នៅក្នុងការប្រកួត។
";) ?> លទ្ធផលនៃការអនុវត្តស្គ្រីប៖ ចំណាត់ថ្នាក់ទី 1 - រង្វាន់: 2800 រូប្លិ៍។ កន្លែងទី 2 - រង្វាន់: 1200 រូប្លិ៍។ ចំណាត់ថ្នាក់ទី 3 - រង្វាន់: 500 រូប្លិ៍។
នៅពេលធ្វើការលើគេហទំព័រជាច្រើន សំណួរនៃការតម្រៀបទិន្នន័យអារេតាមលំដាប់អក្ខរក្រមតែងតែកើតឡើង។ មនុស្សជាច្រើនសរសេរអារេបន្ថែមសម្រាប់វា ប្រៀបធៀបតារាងធំ ហើយសរសេរដដែលៗលើឈ្មោះនីមួយៗ... ជម្រើសនេះមិនល្អបំផុតទេ ទោះបីជាយើងក៏នឹងពិចារណាវាដែរ។ នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់ស្នើវិធីសាមញ្ញបំផុត និងខ្លីបំផុត ដែលប្រសិនបើអ្នកអានសៀវភៅណែនាំដោយប្រុងប្រយ័ត្ន អាចត្រូវបានរកឃើញនៅក្នុងឯកសារ។
អារេអក្ខរក្រម PHP
វិធីសាស្រ្តគឺសាមញ្ញណាស់ ហើយមានពីរជំហាន៖ ការកំណត់មូលដ្ឋាន (setlocal) និងតម្រៀបអារេដោយផ្ទាល់។ តោះមើលឧទាហរណ៍ជាមួយមតិយោបល់។កូដ PHP
setlocale(LC_ALL, "Russian_Russia.1251"); // កំណត់មូលដ្ឋានសម្រាប់អក្សររុស្ស៊ី
// ឧទាហរណ៍នៃអារេដែលពាក្យមិនស្ថិតក្នុងលំដាប់
$example=array("jar","Boris","view","កម្រងសំណួរ"," gamekeeper","Fedor","wife","voice");
Natcasesort($example, SORT_LOCALE_STRING); // តម្រៀបអារេដោយគ្មានភាពរសើបករណី
// ដើម្បីក្លាយជាករណីរសើប សូមប្រើតម្រៀបជំនួសឱ្យ natcasesort
// បង្ហាញលទ្ធផល
foreach ($example as $key => $value)(
បន្ទរ "$value"; // បង្ហាញតែពាក្យ ដោយគ្មានលិបិក្រម
}
?>
បាតុកម្ម ទាញយកប្រភព
នៅក្នុងការបង្ហាញ អ្នកអាចមើលឃើញស្គ្រីបនៅក្នុងសកម្មភាព។ ប្រសិនបើអ្នកចង់បាន អ្នកក៏អាចទាញយកប័ណ្ណសារជាមួយឯកសារផងដែរ។
ប្រសិនបើម៉ាស៊ីនមេរបស់អ្នកមិននៅលើ Windows នោះអ្នកនឹងត្រូវដំឡើងមូលដ្ឋានផ្សេងទៀត ឬជាច្រើនក្នុងពេលតែមួយ៖
(LC_ALL,"ru_RU.CP1251", "rus_RUS.CP1251", "Russian_Russia.1251");!}
// បោះពុម្ព ru_RU.CP1251 សម្រាប់ FreeBSD
// បោះពុម្ព rus_RUS.CP1251 សម្រាប់លីនុច
// បោះពុម្ព Russian_Russia.1251 សម្រាប់ Windows
ខ្ញុំនឹងទទួលបានមុនការឆ្លើយសំណួរមួយក្នុងចំណោមសំណួរ - មូលដ្ឋានសម្រាប់អ៊ុយក្រែននៅក្នុង PHP មើលទៅដូចនេះ:
តើធ្វើដូចម្តេចដើម្បីកំណត់មូលដ្ឋានសម្រាប់ការអ៊ិនកូដផ្សេងទៀតនៅក្នុង PHP?
// ដំឡើងមូលដ្ឋានសម្រាប់វីនដូ
// ការអ៊ិនកូដវីនដូ-1251
setlocale(LC_ALL, "Russian_Russia.1251");
// អ៊ិនកូដ KOI8-R
setlocale(LC_ALL, "Russian_Russia.20866");
// ការអ៊ិនកូដ UTF-8 (ប្រើដោយប្រុងប្រយ័ត្ន)
setlocale(LC_ALL, "Russian_Russia.65001");
?>
វិធីទីពីរដើម្បីរៀបចំអារេតាមលំដាប់អក្សរក្រម PHP
ប្រសិនបើវិធីសាស្ត្រនេះមិនសមនឹងអ្នក ហើយអ្នកចង់ទៅផ្លូវលំបាកនោះ ចូរបង្កើតអារេដូចនេះ៖កូដ PHP
=> ក
=> ខ
=> ក្នុង
=> g
=> ឃ
=> អ៊ី
=> ё
=> វ
=> ស
=> និង
=> ទី
=> ទៅ
=> អិល
=> ម
=> ន
=> o
=> ទំ
=> ទំ
=> ជាមួយ
=> t
=> យ
=> ច
=> x
=> ts
=> ម៉ោង
=> វ
=> sch
=> ъ
=> ស
=> ខ
=> អូ
=> យូ
=> ខ្ញុំ
ហើយធ្វើម្តងទៀតលើអារេទីពីរដោយអក្សរទីមួយ។
យើងគណនាអក្សរទីមួយនៃធាតុអារេណាមួយដូចខាងក្រោមៈ
កូដ PHP
$city="ម៉ូស្គូ"; // ឧទាហរណ៍ធាតុជាមួយលិបិក្រម 1
$first_letter = mb_substr($city,0,1,"UTF-8"); // ទទួលបានអក្សរ "M"
ដោយសារយើងកំពុងធ្វើការជាមួយអក្សររុស្ស៊ី (ការអ៊ិនកូដពហុបៃ) វាជាការប្រសើរក្នុងការប្រើប្រាស់មុខងារ mb_substrហើយនៅចុងបញ្ចប់ វាជាការប្រសើរក្នុងការបង្ហាញយ៉ាងច្បាស់អំពីការអ៊ិនកូដនៃទិន្នន័យអថេរ ឬអារេ ក្នុងករណីរបស់យើង UTF-8 ។
សូមអរគុណចំពោះការយកចិត្តទុកដាក់របស់អ្នក! ខ្ញុំសង្ឃឹមថាព័ត៌មានមានប្រយោជន៍។ ប្រសិនបើអ្នកមានសំណួរសូមសរសេរនៅក្នុងមតិយោបល់។
អារេនៃទិន្នន័យដែលបានវិភាគកាន់តែធំ វាកាន់តែពិបាកផ្តោតទៅលើលក្ខណៈសំខាន់របស់វា។ ដើម្បីយល់កាន់តែច្បាស់អំពីព័ត៌មានដែលមាននៅក្នុងសំណុំទិន្នន័យ វាត្រូវតែរៀបចំឱ្យបានត្រឹមត្រូវ។ ដើម្បីធ្វើដូចនេះសូមប្រើអារេដែលបានបញ្ជាទិញឬដ្យាក្រាមដើមនិងស្លឹក។
អារេដែលបានបញ្ជាទិញ
អារេដែលបានបញ្ជាទិញ (មិនចាំបាច់មានវិមាត្រមួយ) មានលំដាប់នៃទិន្នន័យដែលបានរៀបចំតាមលំដាប់ឡើង។ ឧទាហរណ៍ តារាង (រូបទី 1) មានសូចនាករនៃការត្រឡប់មកវិញប្រចាំឆ្នាំជាមធ្យម 5 ឆ្នាំនៃ 158 មូលនិធិ។ អារេដែលបានបញ្ជាទិញអនុញ្ញាតឱ្យអ្នកកំណត់ភ្លាមៗនូវតម្លៃអប្បបរមា និងអតិបរមា តម្លៃធម្មតា ក៏ដូចជាជួរដែលតម្លៃភាគច្រើនជារបស់។
អង្ករ។ 1. អារេដែលបានបញ្ជាទិញដែលមានទិន្នន័យលើការត្រឡប់មកវិញប្រចាំឆ្នាំជាមធ្យម 5 ឆ្នាំនៃមូលនិធិ 158 ដែលផ្តោតលើកំណើនដើមទុនយ៉ាងឆាប់រហ័សសម្រាប់រយៈពេលពីថ្ងៃទី 1 ខែមករា ឆ្នាំ 1997 ដល់ថ្ងៃទី 31 ខែធ្នូ ឆ្នាំ 2001
ទាញយកចំណាំជាទម្រង់ ឬឧទាហរណ៍ជាទម្រង់
វាអាចត្រូវបានគេមើលឃើញថាកម្រិតទាបបំផុតនៃការត្រឡប់មកវិញប្រចាំឆ្នាំជាមធ្យមប្រាំឆ្នាំគឺ -6.1% ក្នុងមួយឆ្នាំ ហើយខ្ពស់បំផុតឈានដល់ 26.3% ។ លើសពីនេះទៀតការអនុវត្តប្រចាំឆ្នាំជាមធ្យមនៃមូលនិធិភាគច្រើនមានចាប់ពី 5 ទៅ 15% ។ ទោះយ៉ាងណាក៏ដោយ ការបង្ហាញទិន្នន័យក្នុងទម្រង់ជាអារេពីរវិមាត្រ (ដូចក្នុងរូបទី 1) គឺមិនល្អបំផុតទេ ព្រោះវាមិនអនុញ្ញាតឱ្យអ្នកបង្កើតតារាងជំនួយទិន្នន័យបានលឿន និងងាយស្រួលនោះទេ។ ដូច្នេះ ខ្ញុំសូមណែនាំឱ្យបង្កើតអារេលំដាប់បញ្ឈរមួយវិមាត្រ។ Excel ផ្តល់ជម្រើសជាច្រើនសម្រាប់ធ្វើកិច្ចការនេះ។
អនុញ្ញាតឱ្យយើងពិចារណាជាឧទាហរណ៍កាត់មួយ សីតុណ្ហភាពជាមធ្យមប្រចាំខែខែកក្កដានៅទីក្រុងម៉ូស្គូក្នុងរយៈពេល 130 ឆ្នាំនៃការសង្កេត (រូបភាពទី 2) ។
អង្ករ។ 2. សីតុណ្ហភាពប្រចាំខែជាមធ្យមក្នុងខែកក្កដានៅទីក្រុងម៉ូស្គូ; ទិន្នន័យប្រភព
វិធីសាមញ្ញបំផុតក្នុងការរៀបចំសំណុំទិន្នន័យត្រូវបានផ្តល់ដោយជម្រើស Excel តម្រៀប. ជ្រើសរើសជួរ A និង B; ចូលទៅកាន់ម៉ឺនុយ ទិន្នន័យ → ការតម្រៀប (រូបភាពទី 3) ។ ម៉ឺនុយមួយនឹងបើក ការតម្រៀប. នៅក្នុងវាល តម្រៀបតាមជ្រើសរើស សីតុណ្ហភាពខែកក្កដាជាមធ្យម°C, នៅក្នុងវាល បញ្ជាទិញ – ឡើង. ចុច យល់ព្រម។
អង្ករ។ 3. ការតម្រៀបទិន្នន័យ
អ្នកនឹងទទួលបានបញ្ជីដែលបានតម្រៀប (តាមលំដាប់) តាមសីតុណ្ហភាព (រូបភាពទី 4)។ វាច្បាស់ណាស់ថាសីតុណ្ហភាពជាមធ្យមប្រចាំខែអប្បបរមាក្នុងខែកក្កដាត្រូវបានកត់ត្រានៅទីក្រុងមូស្គូក្នុងឆ្នាំ 1904 - 14.6 ° C និងខ្ពស់បំផុតក្នុងឆ្នាំ 2010 - 26.1 ° C ។ ប្រហែលជានៅចាំឆ្នាំដ៏សែនអាក្រក់នេះទេ! សូមចំណាំថាកំណត់ត្រាមុនគឺលើសពី 10% ។
អង្ករ។ 4. បញ្ជីលំដាប់
ដ្យាក្រាមដើមនិងស្លឹក
ដ្យាក្រាមដើមនិងស្លឹកគឺជាឧបករណ៍សម្រាប់ មើលឃើញរៀបចំសំណុំទិន្នន័យ និងវិភាគការចែកចាយរបស់វា។ ទិន្នន័យនៅក្នុងគំនូសតាងមួយត្រូវបានចែកចាយតាមលេខនាំមុខ ឬដើម និងលេខបន្តបន្ទាប់ ឬស្លឹក។ ជាឧទាហរណ៍ លេខ 18.9 ក្នុងដ្យាក្រាម ប្រម៉ោយ និងស្លឹកមានប្រម៉ោយ 18 និងស្លឹក 9 (រូបទី 5)។ ជាអកុសល Excel មិនបង្កើតតារាងដើម និងស្លឹកដោយស្វ័យប្រវត្តិទេ។ ដូច្នេះយើងនឹងប្រើនីតិវិធីដោយដៃ។ យើងប្រើផ្នែកចំនួនគត់នៃសីតុណ្ហភាពជា trunk និងផ្នែកទសភាគជាស្លឹក (សូមមើលរូបមន្តនៅលើសន្លឹក "Trunk and Leaves" នៃឯកសារ Excel ជាដំបូងខ្ញុំបានគូសចំណាំផ្នែកប្រភាគ បន្ទាប់មកផ្ទេរប្រភាគពីជួរឈរ ទៅជួរដេក ហើយទីបំផុតបានធ្វើទ្រង់ទ្រាយតារាងសម្រាប់ធ្វើឱ្យវាមើលឃើញកាន់តែច្រើន)។
អង្ករ។ 5. ដ្យាក្រាមដើមនិងស្លឹក
ដ្យាក្រាមដើម និងស្លឹក បង្ហាញព័ត៌មានយ៉ាងច្រើន។ ឧទាហរណ៍ អ្នកអាចកំណត់ដោយផ្ទាល់នូវតម្លៃអប្បបរមា (14.6) និងអតិបរមា (26.1) ពីវា។ វាអាចត្រូវបានគេមើលឃើញថាតម្លៃភាគច្រើនធ្លាក់ក្នុងចន្លោះ 16...20°C ហើយតម្លៃខ្លួនវាបង្កើតបានជាជាមធ្យមប្រហែល 18°C។ វាក៏មានកន្ទុយធំទូលាយផងដែរនៅក្នុងតំបន់ ខ អូតម្លៃខ្ពស់ជាង។
កិច្ចការសាកល្បង
- ទិន្នន័យខាងក្រោមមានចំនួនមូលប្បទានប័ត្រដែលប្រគល់មកវិញដោយធនាគារចំនួន 23 ទៅកាន់អ្នកដាក់ប្រាក់បញ្ញើរបស់ពួកគេ ដោយសារកង្វះថវិកានៅក្នុងគណនី។ (ចំនួនប្រាក់បញ្ញើអប្បបរមាមិនគួរតិចជាង $100): 26 28 20 20 21 22 25 25 18 25 15 20 18 20 25 25 22 30 30 30 15 20 29 ។
- បង្កើតដ្យាក្រាមដើម និងស្លឹកដែលមានទិន្នន័យដែលបានផ្តល់ឱ្យ។
- កំណត់តម្លៃជុំវិញដែលការចែកចាយចំនួននៃមូលប្បទានប័ត្រត្រឡប់មកវិញត្រូវបានប្រមូលផ្តុំ។
- ទិន្នន័យខាងក្រោមបង្ហាញពីថ្លៃសេវាប្រចាំខែ (គិតជាដុល្លារ) ដែលធនាគារចំនួន 26 គិតថ្លៃអតិថិជនរបស់ពួកគេ ប្រសិនបើសមតុល្យគណនីរបស់អតិថិជនទាបជាង $1,500 អប្បបរមា៖ 12 8 5 5 6 6 10 10 9 7 10 7 7 5 0 10 6 9 12 0 5 ១០ ៨ ៥ ៥ ៩.
- បង្កើតអារេលំដាប់ដែលមានទិន្នន័យដែលបានបញ្ជាក់។
- បង្កើតដ្យាក្រាមដើម និងស្លឹកដែលមានទិន្នន័យដែលបានផ្តល់ឱ្យ។
- តើវិធីមួយណាក្នុងការបង្ហាញទិន្នន័យមានព័ត៌មានច្រើនជាង? បញ្ជាក់ចម្លើយរបស់អ្នក។
- កំណត់តម្លៃជុំវិញការចែកចាយការទូទាត់ប្រចាំខែសម្រាប់សេវាធនាគារត្រូវបានប្រមូលផ្តុំ។
ចម្លើយចំពោះកិច្ចការសាកល្បង
1. សូមមើលសន្លឹក “Control1” នៃឯកសារ Excel និងរូប។ 6. ដ្យាក្រាម stem-and-leaf គឺផ្តល់ព័ត៌មានច្រើនជាងអារេដែលបានបញ្ជា ព្រោះវាមើលឃើញទិន្នន័យបានល្អជាង។ តម្លៃជាមធ្យមគឺប្រហែល 22. ល្បិចសម្រាប់ការងារគឺជ្រើសរើសជំហានសម្រាប់តម្លៃដើម។ ប្រសិនបើអ្នកជ្រើសរើសចំនួនដប់ (10, 20, 30) ជាជំហានមួយ ដ្យាក្រាម "ដើម និងស្លឹក" នឹងបាត់បង់ភាពច្បាស់លាស់របស់វា។
តម្រៀបអារេគឺជាដំណើរការនៃការចែកចាយធាតុទាំងអស់តាមលំដាប់ជាក់លាក់មួយ។ ជាញឹកញាប់វាមានប្រយោជន៍។ ឧទាហរណ៍ ប្រអប់ទទួលរបស់អ្នកបង្ហាញអ៊ីមែលដោយផ្អែកលើពេលវេលាដែលពួកគេបានទទួល។ អ៊ីមែលថ្មីត្រូវបានចាត់ទុកថាពាក់ព័ន្ធជាងអ្វីដែលអ្នកបានទទួលកន្លះម៉ោង មួយម៉ោង ពីរ ឬមួយថ្ងៃមុន នៅពេលអ្នកចូលទៅកាន់បញ្ជីទំនាក់ទំនងរបស់អ្នក ឈ្មោះជាធម្មតាមានតាមលំដាប់អក្ខរក្រម ព្រោះវាងាយស្រួលស្វែងរកអ្វីមួយ។ ករណីទាំងអស់នេះពាក់ព័ន្ធនឹងការតម្រៀបទិន្នន័យមុនពេលចេញវាពិតប្រាកដ។
តើការតម្រៀបដំណើរការយ៉ាងដូចម្តេច?
ការតម្រៀបទិន្នន័យអាចធ្វើឱ្យការស្វែងរកក្នុងអារេកាន់តែមានប្រសិទ្ធភាពមិនត្រឹមតែសម្រាប់មនុស្សប៉ុណ្ណោះទេ ប៉ុន្តែសម្រាប់កុំព្យូទ័រផងដែរ។ ជាឧទាហរណ៍ សូមពិចារណាករណីមួយដែលយើងត្រូវស្វែងរកថាតើឈ្មោះជាក់លាក់មួយលេចឡើងក្នុងបញ្ជីឈ្មោះដែរឬទេ។ ដើម្បីស្វែងយល់ យើងត្រូវពិនិត្យមើលធាតុនីមួយៗនៃអារេធៀបនឹងតម្លៃរបស់យើង។ ការស្វែងរកអារេដែលមានធាតុជាច្រើនអាចគ្មានប្រសិទ្ធភាពពេក (ថ្លៃដើម)។
ទោះយ៉ាងណាក៏ដោយ ចូរសន្មតថាអារេនៃឈ្មោះរបស់យើងត្រូវបានតម្រៀបតាមអក្ខរក្រម។ បន្ទាប់មកការស្វែងរករបស់យើងចាប់ផ្តើមដោយអក្សរទីមួយនៃតម្លៃរបស់យើង ហើយបញ្ចប់ដោយអក្សរដែលមកបន្ទាប់ក្នុងអក្ខរក្រម។ ក្នុងករណីនេះ ប្រសិនបើយើងទៅដល់សំបុត្រនេះហើយរកមិនឃើញឈ្មោះ នោះយើងដឹងច្បាស់ថាវាមិនមែននៅក្នុងអារេដែលនៅសល់ទេ ព្រោះយើងបានឆ្លងកាត់អក្សររបស់យើងតាមលំដាប់អក្ខរក្រមរួចហើយ!
វាមិនមែនជារឿងសម្ងាត់ទេដែលថាមានក្បួនដោះស្រាយដែលប្រសើរជាងសម្រាប់ការស្វែងរកនៅខាងក្នុងអារេដែលបានតម្រៀប។ ដោយប្រើក្បួនដោះស្រាយសាមញ្ញ យើងអាចស្វែងរកធាតុជាក់លាក់មួយនៅក្នុងអារេដែលបានតម្រៀបដែលមានធាតុ 1,000,000 ដោយប្រើការប្រៀបធៀបតែ 20 ប៉ុណ្ណោះ! ជាការពិតណាស់ គុណវិបត្តិគឺថាការតម្រៀបអារេដែលមានធាតុមួយចំនួនធំបែបនេះគឺមានតម្លៃថ្លៃណាស់ ហើយវាមិនត្រូវបានធ្វើសម្រាប់ជាប្រយោជន៍នៃសំណួរស្វែងរកតែមួយនោះទេ។
ក្នុងករណីខ្លះការតម្រៀបអារេធ្វើឱ្យការស្វែងរកមិនចាំបាច់។ ជាឧទាហរណ៍ យើងកំពុងស្វែងរកពិន្ទុល្អបំផុតរបស់សិស្សនៅលើការធ្វើតេស្តមួយ។ ប្រសិនបើអារេមិនត្រូវបានតម្រៀបទេនោះ យើងនឹងត្រូវរកមើលធាតុនីមួយៗនៃអារេ ដើម្បីស្វែងរកពិន្ទុខ្ពស់បំផុត។ ប្រសិនបើអារេត្រូវបានតម្រៀប នោះពិន្ទុខ្ពស់បំផុតនឹងស្ថិតនៅក្នុងទីតាំងដំបូង ឬនៅចុងក្រោយ (អាស្រ័យលើរបៀបដែលអារេត្រូវបានតម្រៀប៖ លំដាប់ឡើង ឬលំដាប់ចុះ) ដូច្នេះយើងមិនចាំបាច់ស្វែងរកទាល់តែសោះ!
ជាធម្មតាការតម្រៀបត្រូវបានធ្វើដោយការប្រៀបធៀបគូនៃធាតុអារេម្តងហើយម្តងទៀត និងជំនួសតម្លៃប្រសិនបើពួកវាបំពេញតាមលក្ខណៈវិនិច្ឆ័យជាក់លាក់។ លំដាប់ដែលធាតុទាំងនេះត្រូវបានប្រៀបធៀបអាស្រ័យលើក្បួនដោះស្រាយការតម្រៀបមួយណាត្រូវបានប្រើ។ លក្ខណៈវិនិច្ឆ័យមានអំពីរបៀបដែលអារេនឹងត្រូវបានតម្រៀប (ឧទាហរណ៍ លំដាប់ឡើង ឬលំដាប់ចុះ)។
ដើម្បីផ្លាស់ប្តូរធាតុពីរ យើងអាចប្រើមុខងារ std :: swap()ពីបណ្ណាល័យស្តង់ដារ C++ ដែលត្រូវបានកំណត់ក្នុងក្បួនដោះស្រាយ។ នៅក្នុង C ++ 11 std:: swap() ត្រូវបានផ្លាស់ទីទៅឯកសារបឋមកថាឧបករណ៍ប្រើប្រាស់៖
# រួមបញ្ចូល
# រួមបញ្ចូល # រួមបញ្ចូល int main() int a = 3; int b = 5; std::cout<< "Before swap: a = " << a << ", b = " << b << "\n" ; std:: swap(a, b); // ប្តូរតម្លៃនៃអថេរ a និង b std::cout<< "After swap: a = " << a << ", b = " << b << "\n" ; |
លទ្ធផលនៃការដំណើរការកម្មវិធីខាងលើ៖
មុន swap: a = 3, b = 5
បន្ទាប់ពី swap៖ a = 5, b = 3
បន្ទាប់ពីអនុវត្តប្រតិបត្តិការជំនួសតម្លៃនៃអថេរ a និង b ត្រូវបានប្តូរ។
ការតម្រៀបអារេដោយប្រើវិធីសាស្ត្រជ្រើសរើស
មានវិធីជាច្រើនដើម្បីតម្រៀបអារេ។ ការតម្រៀបអារេដោយប្រើវិធីសាស្រ្តជ្រើសរើសគឺប្រហែលជាងាយស្រួលបំផុតក្នុងការយល់ បើទោះបីជាវាក៏ជាការយឺតបំផុតមួយ។
សម្រាប់ តម្រៀបអារេដោយជ្រើសរើសពីធាតុតូចបំផុតទៅធំបំផុតជំហានខាងក្រោមត្រូវបានអនុវត្ត៖
ដោយចាប់ផ្តើមជាមួយធាតុនៅសន្ទស្សន៍ 0 យើងរកមើលតម្លៃតូចបំផុតនៅក្នុងអារេ។
តម្លៃដែលបានរកឃើញត្រូវបានប្តូរជាមួយធាតុសូន្យ។
យើងធ្វើម្តងទៀតនូវជំហានលេខ 1 និងលេខ 2 សម្រាប់លិបិក្រមបន្ទាប់នៅក្នុងអារេ។
ម្យ៉ាងវិញទៀត យើងស្វែងរកធាតុតូចបំផុតនៅក្នុងអារេ ហើយផ្លាស់ទីវាទៅកន្លែងដំបូង។ បន្ទាប់មកយើងរកមើលធាតុតូចបំផុតទីពីរ ហើយផ្លាស់ទីវាទៅកន្លែងទីពីរបន្ទាប់ពីធាតុតូចបំផុតទីមួយ។ ដំណើរការនេះបន្តរហូតដល់អារេអស់ធាតុដែលមិនបានតម្រៀប។
នេះជាឧទាហរណ៍មួយនៃរបៀបដែលក្បួនដោះស្រាយនេះដំណើរការក្នុងអារេមួយដែលមានធាតុទាំង ៥៖
{ 30, 50, 20, 10, 40 }
ដំបូងយើងរកមើលធាតុតូចបំផុត ដោយចាប់ផ្តើមពីសន្ទស្សន៍ 0៖
{ 30, 50, 20, 10 , 40 }
បន្ទាប់មកយើងប្តូរធាតុតូចបំផុតជាមួយធាតុនៅសន្ទស្សន៍ 0៖
{ 10 , 50, 20, 30 , 40 }
ឥឡូវនេះ ធាតុទីមួយនៃអារេត្រូវបានតម្រៀប យើងមិនអើពើនឹងវា។ យើងកំពុងស្វែងរកធាតុតូចបំផុតបន្ទាប់ ប៉ុន្តែចាប់ផ្តើមពីលិបិក្រមទី 1៖
{ 10 , 50, 20 , 30, 40 }
ហើយប្តូរវាជាមួយធាតុនៅលិបិក្រម 1:
{ 10 , 20 , 50 , 30, 40 }
ឥឡូវនេះយើងអាចមិនអើពើធាតុពីរដំបូង។ យើងរកមើលធាតុតូចបំផុតបន្ទាប់ ដោយចាប់ផ្តើមនៅលិបិក្រម 2៖
{ 10 , 20 , 50, 30 , 40 }
ហើយប្តូរវាជាមួយធាតុនៅលិបិក្រម 2:
{ 10 , 20 , 30 , 50 , 40 }
យើងរកមើលធាតុតូចបំផុតបន្ទាប់ ដោយចាប់ផ្តើមពីលិបិក្រមទី 3៖
{ 10 , 20 , 30 , 50, 40 }
ហើយប្តូរវាជាមួយធាតុនៅលិបិក្រម 3៖
{ 10 , 20 , 30 , 40 , 50 }
យើងរកមើលធាតុតូចបំផុតបន្ទាប់ ដោយចាប់ផ្តើមពីលិបិក្រមទី 4៖
{ 10 , 20 , 30 , 40 , 50 }
ហើយយើងប្តូរវាជាមួយធាតុនៅលិបិក្រម 4 (ការជំនួសខ្លួនឯងត្រូវបានអនុវត្ត ពោលគឺយើងមិនធ្វើអ្វីទាំងអស់)៖
{ 10 , 20 , 30 , 40 50 }
{ 10, 20, 30, 40, 50 }
ចំណាំថាការប្រៀបធៀបចុងក្រោយនឹងតែងតែជាការប្រៀបធៀបតែមួយ (ឧ. ការជំនួសដោយខ្លួនឯង) ដែលជាប្រតិបត្តិការដែលមិនចាំបាច់ ដូច្នេះតាមពិតយើងអាចបញ្ឈប់ការតម្រៀបមុនពេលធាតុចុងក្រោយនៃអារេ។
ការតម្រៀបអារេដោយប្រើវិធីសាស្ត្រជ្រើសរើសក្នុង C++
នេះជារបៀបដែលក្បួនដោះស្រាយនេះត្រូវបានអនុវត្តនៅក្នុង C ++៖
# រួមបញ្ចូល
# រួមបញ្ចូល # រួមបញ្ចូល int main() const int length = 5; // រង្វិលជុំតាមធាតុនីមួយៗនៃអារេ // (លើកលែងតែមួយចុងក្រោយ វានឹងត្រូវបានតម្រៀបតាមពេលដែលយើងទៅដល់វា) < length - 1 ; ++ startIndex ) // អថេរសន្ទស្សន៍តូចបំផុតរក្សាទុកលិបិក្រមនៃតម្លៃតូចបំផុតដែលយើងបានរកឃើញក្នុងការធ្វើម្តងទៀតនេះ។ // ចាប់ផ្តើមជាមួយធាតុតូចបំផុតក្នុងការធ្វើឡើងវិញនេះជាធាតុទីមួយ (សន្ទស្សន៍ 0) int smallestIndex = startIndex ; // បន្ទាប់មករកមើលធាតុតូចជាងនៅក្នុងអារេដែលនៅសល់ < length ; ++ currentIndex ) // ប្រសិនបើយើងរកឃើញធាតុដែលតូចជាងធាតុតូចបំផុតរបស់យើង ប្រសិនបើ (អារេ [សន្ទស្សន៍បច្ចុប្បន្ន]< array [ smallestIndex ] ) // បន្ទាប់មកចងចាំវា។ សន្ទស្សន៍តូចបំផុត = សន្ទស្សន៍បច្ចុប្បន្ន ; // សន្ទស្សន៍តូចបំផុតឥឡូវនេះគឺជាធាតុតូចបំផុត។ // ប្តូរលេខតូចបំផុតដំបូងរបស់យើងជាមួយនឹងលេខដែលយើងបានរកឃើញ std:: swap(array[startIndex], array[smallestIndex]); // ឥឡូវនេះអារេទាំងមូលត្រូវបានតម្រៀប បង្ហាញវានៅលើអេក្រង់ សម្រាប់ (int index = 0; index< length ; ++ index ) std::cout<< array [ index ] << " " ; ត្រឡប់ 0; |
ផ្នែកដែលច្របូកច្របល់បំផុតនៃក្បួនដោះស្រាយនេះគឺនៅខាងក្នុងរង្វិលជុំមួយទៀត (ហៅថារង្វិលជុំដែលជាប់)។ រង្វិលជុំខាងក្រៅ (startIndex) ធ្វើម្តងទៀតតាមរយៈធាតុម្តងមួយៗ (ម្តងមួយៗ) ។ ក្នុងការធ្វើឡើងវិញនីមួយៗនៃរង្វិលជុំខាងក្រៅ រង្វិលជុំខាងក្នុង (សន្ទស្សន៍បច្ចុប្បន្ន) ត្រូវបានប្រើដើម្បីស្វែងរកធាតុតូចបំផុតក្នុងចំណោមធាតុដែលនៅសល់ក្នុងអារេ (ចាប់ផ្តើមពី startIndex + 1) ។ smallestIndex តាមដានសន្ទស្សន៍នៃធាតុតូចបំផុតដែលរកឃើញដោយរង្វិលជុំខាងក្នុង។ បន្ទាប់មក សន្ទស្សន៍តូចបំផុតផ្លាស់ប្តូរតម្លៃពី startIndex ។ ទីបំផុត រង្វិលជុំខាងក្រៅ (startIndex) ឆ្លងកាត់ធាតុនេះ ហើយដំណើរការនេះកើតឡើងម្តងទៀត។
តម្រុយ៖ប្រសិនបើអ្នកមានបញ្ហាក្នុងការយល់ដឹងពីរបៀបដែលកម្មវិធីខាងលើដំណើរការ សូមសាកល្បងសរសេរវានៅលើក្រដាសមួយ។ សរសេរធាតុចាប់ផ្តើម (មិនតម្រៀប) នៃអារេផ្ដេកនៅលើបន្ទាត់មួយនៅផ្នែកខាងលើនៃសន្លឹកកិច្ចការ។ គូរព្រួញដែលបង្ហាញពីធាតុណាមួយជា startIndex សន្ទស្សន៍បច្ចុប្បន្ន និងសន្ទស្សន៍តូចបំផុតនៅពេលនេះ។ បង្វិលកម្មវិធីដោយដៃ ហើយគូសព្រួញឡើងវិញនៅពេលសន្ទស្សន៍ផ្លាស់ប្តូរ។ បន្ទាប់ពីការធ្វើម្តងទៀតនៃរង្វិលជុំខាងក្រៅនីមួយៗ សូមគូសបន្ទាត់ថ្មីដែលបង្ហាញពីស្ថានភាពបច្ចុប្បន្ននៃអារេ (ទីតាំងនៃធាតុរបស់វា)។
ការតម្រៀបអត្ថបទត្រូវបានអនុវត្តដោយប្រើក្បួនដោះស្រាយដូចគ្នា។ គ្រាន់តែផ្លាស់ប្តូរប្រភេទអារេពី -a ទៅ ហើយចាប់ផ្តើមវាជាមួយនឹងតម្លៃសមស្រប។
std::sort()
ដោយសារប្រតិបត្តិការនៃការតម្រៀបអារេគឺជារឿងធម្មតាណាស់ បណ្ណាល័យស្តង់ដារ C++ ផ្តល់នូវមុខងារតម្រៀបដែលភ្ជាប់មកជាមួយ − std::sort(). វាមានទីតាំងនៅក្នុងឯកសារបឋមកថា algorithm ហើយត្រូវបានគេហៅថាដូចខាងក្រោម៖
# រួមបញ្ចូល
# រួមបញ្ចូល # រួមបញ្ចូល int main() const int length = 5; int អារេ [ប្រវែង] = (30, 50, 20, 10, 40); std::sort(អារេ អារេ + ប្រវែង); សម្រាប់ (int i = 0; i< length ; ++ i ) std::cout<< array [ i ] << " " ; ត្រឡប់ 0; |
សាកល្បង
កិច្ចការទី 1
សរសេរនៅលើក្រដាសមួយពីរបៀបតម្រៀបអារេខាងក្រោមដោយប្រើវិធីសាស្ត្រជ្រើសរើស (ដូចដែលយើងបានធ្វើខាងលើ)៖
{30, 60, 20, 50, 40, 10}
ចម្លើយ #1
30 60 20 50 40 10
10
60 20 50 40 30
10 20
60
50 40 30
10 20 30
50 40 60
10 20 30 40
50
60
10 20 30 40 50
60 (ការជំនួសដោយខ្លួនឯង)
10 20 30 40 50 60
(ការជំនួសខ្លួនឯង)
កិច្ចការទី 2
សរសេរកូដកម្មវិធីឡើងវិញពីចំណងជើងរង “តម្រៀបអារេតាមការជ្រើសរើសក្នុង C ++” ដូច្នេះការតម្រៀបត្រូវបានធ្វើតាមលំដាប់ចុះ (លេខធំបំផុតទៅតូចបំផុត)។ ទោះបីជាវាហាក់ដូចជាស្មុគស្មាញនៅ glance ដំបូងក៏ដោយវាពិតជាសាមញ្ញណាស់។
ចម្លើយ #2
គ្រាន់តែផ្លាស់ប្តូរ៖
ប្រសិនបើ (អារេ< array)
ប្រសិនបើ (អារេ [សន្ទស្សន៍បច្ចុប្បន្ន]< array [ smallestIndex ] ) |
ប្រសិនបើ (អារេ> អារេ)
ប្រសិនបើ (អារេ [ សន្ទស្សន៍បច្ចុប្បន្ន ] > អារេ [ សន្ទស្សន៍តូចបំផុត ]) |
សន្ទស្សន៍តូចបំផុតគួរតែត្រូវបានប្តូរឈ្មោះទៅជា សន្ទស្សន៍ធំបំផុត៖
# រួមបញ្ចូល
# រួមបញ្ចូល # រួមបញ្ចូល int main() const int length = 5; int អារេ [ប្រវែង] = (30, 50, 20, 10, 40); ) // ប្តូរលេខចាប់ផ្តើមរបស់យើងជាមួយនឹងធាតុធំបំផុតដែលបានរកឃើញ std:: swap(array, array); ) សម្រាប់ (int index = 0; index< length - 1 ; ++ startIndex ) // រង្វិលជុំតាមគ្រប់ធាតុនៃអារេ លើកលែងតែធាតុចុងក្រោយ សម្រាប់ (int startIndex = 0; startIndex // biggestIndex គឺជាសន្ទស្សន៍នៃធាតុធំបំផុតដែលយើងបានរកឃើញរហូតមកដល់ពេលនេះ int biggestIndex = startIndex ;< length ; ++ currentIndex ) // រង្វិលជុំតាមធាតុនីមួយៗនៃអារេចាប់ផ្តើមពី startIndex + 1 សម្រាប់ (int currentIndex = startIndex + 1; currentIndex // ប្រសិនបើធាតុបច្ចុប្បន្នធំជាងធាតុធំបំផុតរបស់យើង ប្រសិនបើ (អារេ [សន្ទស្សន៍បច្ចុប្បន្ន] > អារេ [សន្ទស្សន៍ធំជាងគេ]) // បន្ទាប់មកនេះគឺជាធាតុធំបំផុតថ្មីក្នុងការធ្វើម្តងទៀតនេះ។ សន្ទស្សន៍ធំបំផុត = សន្ទស្សន៍បច្ចុប្បន្ន ; // ប្តូរលេខចាប់ផ្តើមរបស់យើងជាមួយនឹងធាតុធំបំផុតដែលបានរកឃើញ សម្រាប់ (int index = 0; index< length ; ++ index ) std::cout<< array [ index ] << " " ; ត្រឡប់ 0; |
std:: swap (អារេ [ សន្ទស្សន៍ចាប់ផ្តើម ] , អារេ [ សន្ទស្សន៍ធំជាងគេ ] );
// បង្ហាញអារេដែលបានតម្រៀបនៅលើអេក្រង់
កិច្ចការទី 3 ភារកិច្ចនេះគឺពិបាកជាងបន្តិច។វិធីសាស្រ្តសាមញ្ញមួយផ្សេងទៀតសម្រាប់ការតម្រៀបធាតុគឺ "ប្រភេទពពុះ"(ឬផ្សេងទៀត។
"ប្រភេទពពុះ" ) គំនិតនេះគឺដើម្បីប្រៀបធៀបតម្លៃគូដែលនៅជិត ហើយប្រសិនបើលក្ខណៈវិនិច្ឆ័យដែលបានបញ្ជាក់ត្រូវបានបំពេញ នោះតម្លៃពីគូនេះត្រូវបានប្តូរ។ ហើយដូច្នេះធាតុ "ពពុះ" ទៅចុងបញ្ចប់នៃអារេ។ ទោះបីជាមានវិធីជាច្រើនដើម្បីបង្កើនប្រសិទ្ធភាពការតម្រៀបពពុះក៏ដោយ សម្រាប់កិច្ចការនេះ យើងនឹងនៅជាប់ជាមួយនឹងកំណែដែលមិនធ្វើឱ្យប្រសើរព្រោះវាសាមញ្ញជាង។:
សម្រាប់កំណែដែលមិនធ្វើឱ្យប្រសើរនៃប្រភេទពពុះ ជំហានខាងក្រោមត្រូវបានអនុវត្តទៅ៖
តម្រៀបអារេពីតម្លៃតូចបំផុតទៅធំបំផុត
ធាតុអារេនៅសន្ទស្សន៍ 0 ត្រូវបានប្រៀបធៀបជាមួយធាតុអារេនៅលិបិក្រម 1 ។ ប្រសិនបើធាតុនៅលិបិក្រម 0 ធំជាងធាតុនៅលិបិក្រម 1 នោះតម្លៃត្រូវបានប្តូរ។
បន្ទាប់មកយើងផ្លាស់ទីទៅគូបន្ទាប់នៃតម្លៃ៖ ធាតុនៅលិបិក្រម 1 និងធាតុនៅលិបិក្រម 2 ហើយបន្តរហូតដល់យើងឈានដល់ចុងបញ្ចប់នៃអារេ។
ធ្វើជំហាន #1 និងជំហាន #2 ម្តងទៀតរហូតដល់អារេទាំងមូលត្រូវបានតម្រៀប។
សរសេរកម្មវិធីដែលនឹងតម្រៀបអារេខាងក្រោមដោយប្រើការតម្រៀបពពុះយោងទៅតាមច្បាប់ខាងលើ៖ |
const int length(9); អារេ int = ( 7, 5, 6, 4, 9, 8, 2, 1, 3);
តម្រុយ៖ប្រសិនបើយើងអាចតម្រៀបធាតុតែមួយក្នុងការធ្វើម្តងទៀត នោះមានន័យថាយើងនឹងត្រូវធ្វើរង្វិលជុំម្តងទៀតឱ្យបានច្រើនដង ដោយសារមានលេខនៅក្នុងអារេរបស់យើង (ប្រវែងរបស់វា) ដើម្បីធានាថាអារេទាំងមូលត្រូវបានតម្រៀប។
ចម្លើយ #3
# រួមបញ្ចូល
# រួមបញ្ចូល # រួមបញ្ចូល int main() សរសេរកម្មវិធីដែលនឹងតម្រៀបអារេខាងក្រោមដោយប្រើការតម្រៀបពពុះយោងទៅតាមច្បាប់ខាងលើ៖ ) ) // បង្ហាញអារេដែលបានតម្រៀបនៅលើអេក្រង់សម្រាប់ (int index = 0; index int អារេ [ប្រវែង] = (7, 5, 6, 4, 9, 8, 2, 1, 3);< length - 1 ; ++ iteration ) សម្រាប់ (int iteration = 0; iteration // រង្វិលជុំតាមធាតុអារេនីមួយៗរហូតដល់ធាតុចុងក្រោយ (មិនរាប់បញ្ចូល) // ធាតុចុងក្រោយមិនមានគូដើម្បីប្រៀបធៀបទេ។< length - 1 ; ++ សម្រាប់ (int currentIndex = 0; currentIndex) { សន្ទស្សន៍បច្ចុប្បន្ន // ប្រសិនបើធាតុបច្ចុប្បន្នធំជាងធាតុបន្ទាប់ពីវា បន្ទាប់មកប្តូរពួកវា(ប្រសិនបើ[ សម្រាប់ (int currentIndex = 0; currentIndex] > ប្រសិនបើ[ សម្រាប់ (int currentIndex = 0; currentIndex+ 1 ] ) អារេ:: ស្ត(ប្រសិនបើ[ សម្រាប់ (int currentIndex = 0; currentIndex] , ប្រសិនបើ[ សម្រាប់ (int currentIndex = 0; currentIndex+ 1 ] ) ; } } // ប្តូរលេខចាប់ផ្តើមរបស់យើងជាមួយនឹងធាតុធំបំផុតដែលបានរកឃើញ ប្តូរ(សម្រាប់int= 0 ; int< សន្ទស្សន៍; ++ int) អារេ:: ប្រវែង<< ប្រសិនបើ[ int] << " " ; cout0 ; } |
ត្រឡប់មកវិញ
កិច្ចការទី 4
អនុវត្តដំណោះស្រាយបង្កើនប្រសិទ្ធភាពពីរខាងក្រោមសម្រាប់ក្បួនដោះស្រាយការតម្រៀបពពុះដែលអ្នកបានសរសេរនៅក្នុងកិច្ចការមុន៖