អត្ថបទពិភាក្សាអំពីក្បួនដោះស្រាយការតម្រៀបដ៏ពេញនិយមបំផុតមួយចំនួនសម្រាប់អារេ ដែលប្រើទាំងការអនុវត្ត និងសម្រាប់គោលបំណងអប់រំ។ ខ្ញុំចង់ធ្វើការកក់ទុកភ្លាមៗថា រាល់ក្បួនដោះស្រាយដែលបានពិចារណាគឺយឺតជាងវិធីសាស្ត្របុរាណក្នុងការតម្រៀបអារេតាមបញ្ជីតម្លៃ ប៉ុន្តែយ៉ាងណាក៏ដោយ ពួកគេសមនឹងទទួលបានការយកចិត្តទុកដាក់។ មានអត្ថបទច្រើន ដូច្នេះសម្រាប់ក្បួនដោះស្រាយនីមួយៗ ខ្ញុំពិពណ៌នាអំពីមូលដ្ឋានបំផុត។

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។ វាក៏មានកន្ទុយធំទូលាយផងដែរនៅក្នុងតំបន់ ខ អូតម្លៃខ្ពស់ជាង។

កិច្ចការសាកល្បង

1. ទិន្នន័យខាងក្រោមមានចំនួនមូលប្បទានប័ត្រដែលប្រគល់មកវិញដោយធនាគារចំនួន 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 ។
   1. បង្កើតដ្យាក្រាមដើម និងស្លឹកដែលមានទិន្នន័យដែលបានផ្តល់ឱ្យ។
   2. កំណត់តម្លៃជុំវិញដែលការចែកចាយចំនួននៃមូលប្បទានប័ត្រត្រឡប់មកវិញត្រូវបានប្រមូលផ្តុំ។
2. ទិន្នន័យខាងក្រោមបង្ហាញពីថ្លៃសេវាប្រចាំខែ (គិតជាដុល្លារ) ដែលធនាគារចំនួន 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. បង្កើតអារេលំដាប់ដែលមានទិន្នន័យដែលបានបញ្ជាក់។
   2. បង្កើតដ្យាក្រាមដើម និងស្លឹកដែលមានទិន្នន័យដែលបានផ្តល់ឱ្យ។
   3. តើ​វិធី​មួយ​ណា​ក្នុង​ការ​បង្ហាញ​ទិន្នន័យ​មាន​ព័ត៌មាន​ច្រើន​ជាង? បញ្ជាក់ចម្លើយរបស់អ្នក។
   4. កំណត់តម្លៃជុំវិញការចែកចាយការទូទាត់ប្រចាំខែសម្រាប់សេវាធនាគារត្រូវបានប្រមូលផ្តុំ។

ចម្លើយចំពោះកិច្ចការសាកល្បង

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"; }

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា 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 ++៖

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា int main() ( const int length = 5; int array = ( 30, 50, 20, 10, 40); // ធ្វើម្តងទៀតតាមរយៈធាតុនីមួយៗនៃអារេ // (លើកលែងតែមួយចុងក្រោយ វានឹងត្រូវបានតម្រៀបរួចហើយដោយ ពេលវេលាដែលយើងទៅដល់វា តោះទៅទីនោះ) សម្រាប់ (int startIndex = 0; startIndex< length - 1; ++startIndex) { // В переменной smallestIndex хранится индекс наименьшего значения, которое мы нашли в этой итерации // Начинаем с того, что наименьший элемент в этой итерации - это первый элемент (индекс 0) int smallestIndex = startIndex; // Затем ищем элемент поменьше в остальной части массива for (int currentIndex = startIndex + 1; currentIndex < length; ++currentIndex) { // Если мы нашли элемент, который меньше нашего наименьшего элемента, if (array < array) // то запоминаем его smallestIndex = currentIndex; } // smallestIndex теперь наименьший элемент // Меняем местами наше начальное наименьшее число с тем, которое мы обнаружили std::swap(array, array); } // Теперь, когда весь массив отсортирован - выводим его на экран for (int index = 0; index < length; ++index) std::cout << array << " "; return 0; }

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា 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 ហើយត្រូវបានគេហៅថាដូចខាងក្រោម៖

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std::sort int main() ( const int length = 5; int array = ( 30, 50, 20, 10, 40); std::sort(array, array+length); for (int i= 0;< length; ++i) std::cout << array[i] << " "; return 0; }

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: តម្រៀប 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 ] )

ប្រសិនបើ (អារេ> អារេ)

ប្រសិនបើ (អារេ [ សន្ទស្សន៍បច្ចុប្បន្ន ] > អារេ [ សន្ទស្សន៍តូចបំផុត ])

សន្ទស្សន៍តូចបំផុតគួរតែត្រូវបានប្តូរឈ្មោះទៅជា សន្ទស្សន៍ធំបំផុត៖

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា int main() ( const int length= 5; int array = ( 30, 50, 20, 10, 40); // រង្វិលជុំតាមរយៈធាតុអារេនីមួយៗ លើកលែងតែចុងក្រោយសម្រាប់ (int startIndex = 0; startIndex< length - 1; ++startIndex) { // largestIndex - это индекс наибольшего элемента, который мы обнаружили до сих пор int largestIndex = startIndex; // Перебираем каждый элемент массива начиная со startIndex + 1 for (int currentIndex = startIndex + 1; currentIndex < length; ++currentIndex) { // Если текущий элемент больше нашего наибольшего элемента, if (array >array) // បន្ទាប់មកនេះគឺជាធាតុធំបំផុតថ្មីនៅក្នុង iteration biggestIndex = currentIndex;< length; ++index) std::cout << array << " "; return 0; }

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា 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

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា int main() ( const int length(9); int array = ( 7, 5, 6, 4, 9, 8, 2, 1, 3); សម្រាប់ (int iteration = 0; iteration< length-1; ++iteration) { // Перебираем каждый элемент массива до последнего элемента (не включительно) // Последний элемент не имеет пары для сравнения for (int currentIndex = 0; currentIndex < length - 1; ++currentIndex) { // Если текущий элемент больше элемента после него, то меняем их местами if (array >អារេ) std :: swap(អារេ អារេ);< length; ++index) std::cout << array << " "; return 0; }

# រួមបញ្ចូល # រួមបញ្ចូល // សម្រាប់ std:: swap ។ នៅក្នុង C++11 ប្រើបឋមកថា 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

អនុវត្តដំណោះស្រាយបង្កើនប្រសិទ្ធភាពពីរខាងក្រោមសម្រាប់ក្បួនដោះស្រាយការតម្រៀបពពុះដែលអ្នកបានសរសេរនៅក្នុងកិច្ចការមុន៖