บทความนี้กล่าวถึงอัลกอริธึมการเรียงลำดับที่ได้รับความนิยมมากที่สุดสำหรับอาร์เรย์ ซึ่งใช้ทั้งในทางปฏิบัติและเพื่อการศึกษา ฉันต้องการจองทันทีว่าอัลกอริธึมที่พิจารณาทั้งหมดช้ากว่าวิธีคลาสสิกในการเรียงลำดับอาร์เรย์ผ่านรายการค่า แต่ถึงกระนั้นพวกเขาก็สมควรได้รับความสนใจ มีข้อความจำนวนมาก ดังนั้นสำหรับแต่ละอัลกอริทึม ฉันจึงอธิบายข้อความพื้นฐานที่สุด

1. อัลกอริทึม "การเรียงลำดับตามตัวเลือก"

มันเป็นหนึ่งในอัลกอริธึมการเรียงลำดับอาเรย์ที่ง่ายที่สุด แนวคิดคือการดูผ่านอาร์เรย์และแต่ละครั้งจะมองหาองค์ประกอบขั้นต่ำของอาร์เรย์ โดยแลกเปลี่ยนกับองค์ประกอบเริ่มต้นของส่วนที่ไม่ได้เรียงลำดับของอาร์เรย์ ในอาร์เรย์ขนาดเล็ก อาจมีประสิทธิภาพมากกว่าอัลกอริธึมการเรียงลำดับที่ซับซ้อนกว่า แต่ไม่ว่าในกรณีใด ก็จะสูญเสียในอาร์เรย์ขนาดใหญ่ จำนวนการแลกเปลี่ยนองค์ประกอบเมื่อเทียบกับอัลกอริทึม "บับเบิ้ล" คือ N/2 โดยที่ N คือจำนวนองค์ประกอบอาร์เรย์

อัลกอริทึม:
1. ค้นหาองค์ประกอบขั้นต่ำในอาร์เรย์
2. สลับองค์ประกอบขั้นต่ำและองค์ประกอบแรก
3. เรามองหาองค์ประกอบขั้นต่ำในส่วนที่ไม่ได้เรียงลำดับของอาร์เรย์อีกครั้ง
4. สลับองค์ประกอบที่สองของอาร์เรย์และองค์ประกอบขั้นต่ำที่พบ เนื่องจากองค์ประกอบแรกของอาร์เรย์คือส่วนที่เรียงลำดับ
5. เราค้นหาค่าต่ำสุดและสลับองค์ประกอบจนกว่าอาร์เรย์จะถูกจัดเรียงจนสุด

// เรียงตามส่วนที่เลือก (--- ฟังก์ชั่น เรียงตามส่วนที่เลือก (อาร์เรย์ค่า) Min = 0; For i = 0 โดย Array.VBoundary() Loop Min = i; For j = i + 1 By Array.VBoundary() Loop / /มองหาองค์ประกอบขั้นต่ำในอาร์เรย์ If Array[j]< Массив[Мин] Тогда Мин = j; КонецЕсли; КонецЦикла; Если Массив [Мин] = Массив [i] Тогда //Если мин. элемент массива = первому элементу неотс. части массива, то пропускаем. Продолжить; КонецЕсли; Смена = Массив[i]; //Производим замену элементов массива. Массив[i] = Массив[Мин]; Массив[Мин] = Смена; КонецЦикла; Возврат Массив; КонецФункции

2. อัลกอริทึม "การเรียงลำดับแบบบับเบิ้ล"

บางทีอัลกอริธึมที่มีชื่อเสียงที่สุดที่ใช้เพื่อการศึกษาอาจช้าเกินไปสำหรับการใช้งานจริง อัลกอริธึมรองรับอัลกอริธึมที่ซับซ้อนมากขึ้น: "Shaker sort", "Pyramid sort", "Quick sort" เป็นที่น่าสังเกตว่าหนึ่งในอัลกอริธึมที่เร็วที่สุด “Fast Algorithm” ได้รับการพัฒนาโดยการอัพเกรดหนึ่งในอัลกอริธึมที่แย่ที่สุด นั่นคือ “Quick” และ “Shaker” จะมีการหารือเพิ่มเติม ความหมายของอัลกอริทึมคือองค์ประกอบที่ "เบาที่สุด" ของอาเรย์ "ลอย" และองค์ประกอบที่ "หนักที่สุด" จะ "จม" จึงเป็นที่มาของชื่อ "Bubble Sort"

อัลกอริทึม:
1. แต่ละองค์ประกอบของอาร์เรย์จะถูกเปรียบเทียบกับองค์ประกอบถัดไป และหากองค์ประกอบ[i] > องค์ประกอบถูกแทนที่ ดังนั้นองค์ประกอบที่ "เบาที่สุด" จะ "ลอย" - ย้ายไปที่จุดเริ่มต้นของรายการและ "อ่างล้างจาน" ที่หนักที่สุด - ย้ายไปที่จุดสิ้นสุด
2. ทำซ้ำขั้นตอนที่ 1 n-1 ครั้ง โดยที่ n คือ Array.Quantity ()

// Bubble Sort (--- ฟังก์ชั่น Bubble Sort (อาร์เรย์ค่า) For i = 0 โดย Array.InBorder() Loop For j = 0 โดย Array.InBorder() - i - 1 Loop If Array[j] > Array แล้วเปลี่ยน = อาร์เรย์ [j]; อาร์เรย์ = EndIf;

3. อัลกอริทึม "การเรียงลำดับ Shaker" (การเรียงลำดับแบบสุ่ม, การเรียงลำดับฟองแบบสองทิศทาง)

อัลกอริทึมเป็นเวอร์ชันของการเรียงลำดับก่อนหน้า - "การเรียงลำดับแบบบับเบิ้ล" ข้อแตกต่างหลักๆ ก็คือ ในการเรียงลำดับแบบฟองสบู่แบบดั้งเดิม จะมีการเคลื่อนที่ขององค์ประกอบในทิศทางเดียวจากล่างขึ้นบน ในขณะที่การเรียงลำดับแบบเชคเกอร์ การเคลื่อนไหวจะเกิดขึ้นจากล่างขึ้นบนก่อน แล้วจึงจากบนลงล่าง

อัลกอริทึมเหมือนกับการเรียงลำดับแบบฟอง + เพิ่มวงจรจากบนลงล่าง

ในตัวอย่างด้านล่าง มีการปรับปรุงการคัดแยกเชคเกอร์ ต่างจากแบบคลาสสิกตรงที่ใช้การวนซ้ำน้อยกว่า 2 เท่า

//จัดเรียงตามการผสม (Shaker-Sort) (--- ฟังก์ชั่นจัดเรียงตามการผสม (อาร์เรย์ค่า) For i = 0 BY Array.VBoundary()/2 Loop nIter = 0; conIter = Array.VBoundary(); While nIter Array [nIter+ 1] จากนั้น การแทนที่ = Array[nIter]; > Array[conIter] จากนั้นการแทนที่ = Array[conIter - 1]; Array[conIter]; // ย้ายตำแหน่งกลับไปหนึ่งขั้น EndCycle;

4. อัลกอริทึม "การเรียงลำดับคนแคระ"

อัลกอริธึมนี้ได้รับการตั้งชื่อแปลกมาก ต้องขอบคุณ Dick Grun นักวิทยาศาสตร์ชาวดัตช์

การคัดแยกคำพังเพยอาศัยเทคนิคที่ใช้โดยคำพังเพยในสวนของชาวดัตช์ (ชาวดัตช์ tuinkabouter) นี่เป็นวิธีการที่พวกคำพังเพยในสวนจัดเรียงกระถางต้นไม้เป็นแนว โดยพื้นฐานแล้ว เขามองไปที่กระถางสวนถัดไปและก่อนหน้า: หากพวกมันอยู่ในลำดับที่ถูกต้อง เขาจะก้าวไปข้างหน้าหนึ่งกระถาง ไม่เช่นนั้นเขาจะสลับกระถางเหล่านั้นและถอยกระถางหนึ่งกลับไป เงื่อนไขขอบเขต: หากไม่มีเงินกองกลางก่อนหน้า มันจะก้าวไปข้างหน้า ถ้าไม่มีหม้อต่อไปก็เสร็จแล้ว
ดิ๊ก กรัน

นั่นคือคำอธิบายทั้งหมดของอัลกอริธึม "การคัดแยกคนแคระ" สิ่งที่น่าสนใจคืออัลกอริธึมไม่มีลูปที่ซ้อนกัน แต่เรียงลำดับอาร์เรย์ทั้งหมดในการส่งผ่านครั้งเดียว

// การเรียงลำดับคนแคระ (--- ฟังก์ชั่น DwarvenSort (อาร์เรย์ค่า) i = 1; j = 2; ในขณะที่ i< Массив.Количество() Цикл // Сравнение < - Сортировка по возрастанию, >- จากมากไปน้อยถ้าอาร์เรย์ i = j;

เจ = เจ + 1;

อื่นแทน = อาร์เรย์ [i];
อาร์เรย์[i] = อาร์เรย์;
อาร์เรย์ = การแทนที่;
ฉัน = ฉัน - 1;
ถ้า i = 0 แล้ว i = 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 รูเบิล - บิลหนึ่งคือ 500 และอีกใบคือ 50 คุณดูกระเป๋าเงินของคุณและมีธนบัตรมูลค่า 10,100,1,000 คุณใส่บิล

อัลกอริทึมนี้ตั้งชื่อตามนักวิทยาศาสตร์ชาวอเมริกัน โดนัลด์ เชล โดยแก่นแท้แล้ว อัลกอริธึมนี้เป็นอัลกอริธึมการเรียงลำดับการแทรกที่ได้รับการปรับปรุง จุดประสงค์ของอัลกอริธึมคือการเปรียบเทียบไม่เพียงแต่องค์ประกอบที่อยู่ติดกัน แต่ยังอยู่ในระยะห่างด้วย ขั้นแรก เลือกขั้นตอน - ช่วงเวลาหนึ่งซึ่งองค์ประกอบอาร์เรย์จะถูกเปรียบเทียบในการวนซ้ำแต่ละครั้ง โดยปกติจะมีการกำหนดไว้ดังนี้:
สำหรับการวนซ้ำครั้งแรก Step = Object(Array.Quantity()/2) สำหรับการวนซ้ำครั้งต่อไป Step = Object(Step/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 และ อาร์เรย์[j] > การเปลี่ยนลูปอาร์เรย์ = อาร์เรย์[j];

อาร์เรย์[j] = อาร์เรย์;

อาร์เรย์ = การแทนที่;
เจ = เจ - 1;

ถ้า ApplyDisplaySortThenDisplaySortChart(Array);< m Цикл i = i + 1; КонецЦикла; Пока Массив[j] >สิ้นสุดถ้า;< j Тогда б_Сортировка(Массив,НижнийПредел,j); КонецЕсли; Если i < ВерхнийПредел Тогда б_Сортировка(Массив,i,ВерхнийПредел); КонецЕсли; КонецПроцедуры Функция БыстраяСортировка(Массив) НижняяГраница = 0; ВерхняяГраница = Массив.ВГраница(); б_Сортировка(Массив,НижняяГраница,ВерхняяГраница); Возврат Массив; КонецФункции //---}

สิ้นสุดรอบ;

ฉัน = ฉัน + 1;

//จัดเรียงตามรายการค่า (--- ฟังก์ชั่นจัดเรียงตามรายการค่า (อาร์เรย์ค่า) mListValues ​​= New ListValues; mListValues.LoadValues(Array); mListValues.SortByValue(SortDirection.Asc); กลับ mListValues.UnloadValues(); EndFunction //---)

การเรียงลำดับทั้งหมดสามารถเร่งความเร็วได้โดยการวางโค้ดไว้ในลูป 1 บรรทัด แต่เพื่อให้อ่านง่าย เลยปล่อยไว้แบบนั้น

ฉันเขียนการประมวลผลที่ใช้อัลกอริธึมข้างต้นทั้งหมด และยังรองรับแอนิเมชั่นไดนามิกของกระบวนการเรียงลำดับอีกด้วย (ยกเว้นการเรียงลำดับมาตรฐาน 1c) .

- เมื่อการประมวลผลเริ่มต้นขึ้น ระบบจะสร้างอาร์เรย์ของตัวเลขสุ่มตั้งแต่ 0 ถึง 100 โดยมีมิติเป็น 100 องค์ประกอบโดยอัตโนมัติ
- หากต้องการสร้างอาร์เรย์อื่น คุณต้องคลิกที่ปุ่ม "สร้างอาร์เรย์ RNG" คุณยังสามารถเลือกช่วงที่ต้องการได้อีกด้วย
- หากต้องการเปิดใช้งานภาพเคลื่อนไหวแบบไดนามิก คุณต้องกาเครื่องหมายที่ช่อง "การเรียงลำดับการแสดงผลในแผนภูมิ" ฉันแนะนำให้คุณทำเครื่องหมายที่ช่องเพื่อดูอัลกอริธึมที่ไม่มีประสิทธิภาพเมื่อขนาดอาร์เรย์มีมากถึง 100 องค์ประกอบ ไม่เช่นนั้นคุณจะแก่เกินไปที่จะรอการเรียงลำดับ :)

การแสดงผลแบบไดนามิกของกระบวนการเรียงลำดับลดประสิทธิภาพลงอย่างมาก แต่คุณสามารถเห็นวิธีการทำงานของอัลกอริทึมได้อย่างชัดเจน

ไม่ช้าก็เร็วโปรแกรมเมอร์จะต้องเรียงลำดับข้อมูลจากอาเรย์ ไม่ว่าจะเป็นการแสดงข้อมูลจากฐานข้อมูลตามลำดับตัวอักษรหรือเรียงลำดับชื่อไฟล์ตามวันที่แก้ไขล่าสุด ก็สามารถทำได้ด้วยฟังก์ชัน PHP ในตัวสำหรับการเรียงลำดับข้อมูลอาร์เรย์ ในบทความนี้ ผมจะสาธิตและอธิบายพร้อมตัวอย่างว่าฟังก์ชันต่างๆ เช่น sort(), rsort() ทำงานอย่างไร

การทำงาน ; - จัดเรียงอาร์เรย์จากน้อยไปหามากและตามลำดับตัวอักษร

โครงสร้าง:

($อาร์เรย์, $ธง);

ฟังก์ชันจะเรียงลำดับอาร์เรย์ที่กำหนดให้ $Array ตามลำดับจากน้อยไปหามาก ฟังก์ชันนี้ออกแบบมาเพื่อทำงานกับรายการ รายการคืออาร์เรย์ธรรมดาซึ่งมีคีย์เริ่มต้นจากศูนย์ ฟังก์ชันนี้สามารถกำหนดอาร์กิวเมนต์ที่เป็นตัวเลือก $Flag ซึ่งจะจัดการสิ่งที่จะเกิดขึ้นอย่างแน่นอน การเรียงลำดับ- พิจารณาคำอธิบายของอาร์กิวเมนต์ $Flag:

SORT_REGULAR– ฟังก์ชั่นการเรียงลำดับเริ่มต้น

SORT_NUMERIC- การเรียงลำดับตัวเลขจากน้อยไปหามาก

SORT_STRING- การเรียงลำดับสตริงตามตัวอักษร

ลองพิจารณาตัวอย่าง: เรามีอาร์เรย์ที่ข้อมูลเกี่ยวกับจำนวนคู่นักเรียนในปีการศึกษาต่างๆ ถูกจัดเก็บในรูปแบบที่ไม่เป็นระเบียบ

"; ) ?> ผลลัพธ์ของสคริปต์: หลักสูตร: 1 - 72 คู่ หลักสูตร: 2 - 83 คู่ หลักสูตร: 3 - 100 คู่ หากเราไม่ได้ประยุกต์ใช้ฟังก์ชัน ผลลัพธ์ของงานจะเป็นดังนี้: หลักสูตร: 1 - 83 คู่ หลักสูตร: 2 - 100 คู่ หลักสูตร: 3 - 72 คู่

เรียงตามตัวอักษร

ด้านล่างนี้เป็นสคริปต์ที่เรียงลำดับประเทศของอาร์เรย์ตามลำดับตัวอักษร ไม่จำเป็นต้องตั้งค่าอาร์กิวเมนต์ที่สองของฟังก์ชัน ($Flag) เนื่องจาก ฟังก์ชั่นจะเข้าใจว่าต้องทำงานกับสตริง

"; ) ?> ผลงาน: อาร์เมเนีย อิตาลี รัสเซีย ญี่ปุ่น

ฟังก์ชั่น rsort() - จัดเรียงอาร์เรย์จากมากไปน้อย

ฟังก์ชันนี้ไร้เหตุผล แต่เรียงลำดับอาร์เรย์จากมากไปน้อย ลองดูที่โครงสร้างไวยากรณ์:

($อาร์เรย์, $ธง);

ตัวอย่างของฟังก์ชันนี้จะคล้ายกับตัวอย่างที่ให้ไว้ข้างต้น ยกเว้นประการหนึ่ง ข้อมูลจากอาร์เรย์จะถูกจัดเรียงจากมากไปน้อย เรากำลังสร้างรางวัลมากมายสำหรับผู้ที่คว้าอันดับที่ 1, 2 และ 3 ในการแข่งขัน

"; ) ?> ผลลัพธ์ของการใช้สคริปต์: อันดับที่ 1 - รางวัล: 2,800 รูเบิล อันดับที่ 2 - รางวัล: 1200 รูเบิล อันดับที่ 3 - รางวัล: 500 รูเบิล

เมื่อทำงานกับไซต์หลายแห่ง คำถามเกี่ยวกับการจัดเรียงข้อมูลอาร์เรย์ตามลำดับตัวอักษรมักเกิดขึ้น หลายคนเขียนอาร์เรย์เพิ่มเติมสำหรับสิ่งนี้ เปรียบเทียบตารางขนาดใหญ่ และวนซ้ำแต่ละชื่อ... ตัวเลือกนี้ไม่ใช่ตัวเลือกที่ดีที่สุด แม้ว่าเราจะพิจารณาด้วยก็ตาม ในบทความนี้ ฉันอยากจะเสนอวิธีที่ง่ายและสั้นที่สุด ซึ่งหากคุณอ่านคู่มืออย่างละเอียด ก็สามารถหาได้จากเอกสารประกอบ

PHP อาร์เรย์ตัวอักษร

วิธีการนี้ค่อนข้างง่ายและประกอบด้วยสองขั้นตอน: การตั้งค่าภาษา (setlocal) และการเรียงลำดับอาร์เรย์โดยตรง ลองดูตัวอย่างพร้อมความคิดเห็น

รหัสพีเอชพี

setlocale(LC_ALL, "Russian_Russia.1251"); // กำหนดสถานที่สำหรับตัวอักษรรัสเซีย

// ตัวอย่างอาร์เรย์ที่คำไม่เรียงลำดับ
$example=array("jar", "Boris", "view", "แบบสอบถาม", "ผู้ดูแลเกม", "Fedor", "ภรรยา", "เสียง");

Natcasesort(ตัวอย่าง $, SORT_LOCALE_STRING); // เรียงลำดับอาร์เรย์โดยไม่คำนึงถึงขนาดตัวพิมพ์
// เพื่อให้คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ให้ใช้ sort แทน natcasesort

// แสดงผล
foreach ($ตัวอย่าง $key => $value)(
echo "$value "; // แสดงเฉพาะคำโดยไม่มีดัชนี
}
?>

สาธิต ดาวน์โหลดแหล่งที่มา
ในการสาธิต คุณสามารถดูสคริปต์ที่ใช้งานจริงได้ หากต้องการคุณสามารถดาวน์โหลดไฟล์เก็บถาวรพร้อมไฟล์ได้

หากเซิร์ฟเวอร์ของคุณไม่ได้อยู่บน Windows คุณจะต้องติดตั้งภาษาอื่นหรือหลายภาษาพร้อมกัน:

(LC_ALL,"ru_RU.CP1251", "rus_RUS.CP1251", "Russian_Russia.1251");!}
// พิมพ์ ru_RU.CP1251 สำหรับ FreeBSD
// พิมพ์ rus_RUS.CP1251 สำหรับ Linux
// พิมพ์ Russian_Russia.1251 สำหรับ Windows

ฉันจะตอบคำถามข้อใดข้อหนึ่งก่อน - สถานที่สำหรับยูเครนใน PHP มีลักษณะดังนี้:

จะตั้งค่าภาษาสำหรับการเข้ารหัสอื่น ๆ ใน PHP ได้อย่างไร

// ติดตั้งโลแคลสำหรับ Windows

// การเข้ารหัส Windows-1251
setlocale(LC_ALL, "Russian_Russia.1251");

// การเข้ารหัส KOI8-R
setlocale(LC_ALL, "Russian_Russia.20866");

// การเข้ารหัส UTF-8 (ใช้อย่างระมัดระวัง)
setlocale(LC_ALL, "Russian_Russia.65001");
?>

วิธีที่สองในการจัดเรียงอาร์เรย์ตามลำดับตัวอักษร PHP

หากวิธีนี้ไม่เหมาะกับคุณและคุณต้องการดำเนินการอย่างหนัก ให้สร้างอาร์เรย์ดังนี้:

รหัสพีเอชพี

=> ก
=> ข
=> ใน
=> ก
=> ง
=> อี
=> ก
=> ว
=> ส
=> และ
=> ธ
=> ถึง
=> ล
=> ม
=> n
=> เกี่ยวกับ
=> หน้า
=> หน้า
=> ด้วย
=> เสื้อ
=> ย
=> ฉ
=> x
=> ทีเอส
=> ฮ
=> ว
=> ช
=> ъ
=> ส
=> ข
=> เอ่อ
=> คุณ
=> ฉัน
และวนซ้ำอาร์เรย์ที่สองด้วยตัวอักษรตัวแรก
เราคำนวณอักษรตัวแรกขององค์ประกอบอาร์เรย์ใด ๆ ดังต่อไปนี้:

รหัสพีเอชพี

$เมือง="มอสโก"; // ตัวอย่างองค์ประกอบที่มีดัชนี 1

$first_letter = mb_substr($เมือง,0,1,"UTF-8"); // รับตัวอักษร "M"
เนื่องจากเรากำลังทำงานกับตัวอักษรรัสเซีย (การเข้ารหัสหลายไบต์) จึงควรใช้ฟังก์ชันนี้จะดีกว่า mb_substrและในตอนท้ายจะเป็นการดีกว่าที่จะระบุการเข้ารหัสของตัวแปรหรือข้อมูลอาเรย์อย่างชัดเจน ในกรณีของเรา UTF-8

ขอบคุณสำหรับความสนใจของคุณ! ฉันหวังว่าข้อมูลจะเป็นประโยชน์ หากคุณมีคำถามเขียนในความคิดเห็น

ยิ่งอาร์เรย์ข้อมูลที่วิเคราะห์มีขนาดใหญ่เท่าใด การมุ่งความสนใจไปที่คุณลักษณะหลักก็จะยิ่งยากขึ้นเท่านั้น เพื่อให้เข้าใจข้อมูลที่อยู่ในชุดข้อมูลได้ดีขึ้น จะต้องมีการจัดระเบียบอย่างเหมาะสม เมื่อต้องการทำเช่นนี้ ให้ใช้อาร์เรย์ที่เรียงลำดับหรือไดอะแกรมลำต้นและใบไม้

อาร์เรย์ที่สั่ง

อาร์เรย์ที่ได้รับคำสั่ง (ไม่จำเป็นต้องมีมิติเดียว) ประกอบด้วยลำดับของข้อมูลที่จัดเรียงจากน้อยไปหามาก ตัวอย่างเช่น ตาราง (รูปที่ 1) มีตัวบ่งชี้ผลตอบแทนเฉลี่ยต่อปี 5 ปีจำนวน 158 กองทุน อาร์เรย์ที่เรียงลำดับช่วยให้คุณสามารถกำหนดค่าต่ำสุดและสูงสุด ค่าทั่วไป รวมถึงช่วงที่ค่าส่วนใหญ่อยู่ได้ทันที

ข้าว. 1. Order Array ที่ประกอบด้วยข้อมูลเกี่ยวกับผลตอบแทนเฉลี่ยต่อปี 5 ปีของ 158 กองทุน ที่เน้นการเติบโตอย่างรวดเร็วของเงินทุนในช่วงตั้งแต่วันที่ 1 มกราคม 1997 ถึง 31 ธันวาคม 2001

ดาวน์โหลดบันทึกในรูปแบบหรือตัวอย่างในรูปแบบ

จะเห็นได้ว่าระดับต่ำสุดของผลตอบแทนเฉลี่ยต่อปีในช่วง 5 ปีคือ -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 ไม่ได้สร้างแผนภูมิก้านและใบโดยอัตโนมัติ ดังนั้นเราจะใช้ขั้นตอนแบบแมนนวล เราใช้ส่วนจำนวนเต็มของอุณหภูมิเป็นลำตัว และส่วนทศนิยมเป็นใบไม้ (ดูสูตรบนแผ่น "ลำต้นและใบไม้" ของไฟล์ Excel ก่อนอื่นฉันเน้นส่วนที่เป็นเศษส่วน จากนั้นจึงโอนเศษส่วนจากคอลัมน์ ลงในแถว และสุดท้ายจัดรูปแบบแผนภูมิเพื่อให้มองเห็นได้ชัดเจนยิ่งขึ้น)

ข้าว. 5. แผนภาพลำต้นและใบ

แผนภาพลำต้นและใบแสดงภาพข้อมูลจำนวนมาก ตัวอย่างเช่น คุณสามารถกำหนดค่าขั้นต่ำ (14.6) และสูงสุด (26.1) ได้โดยตรงจากค่าดังกล่าว จะเห็นได้ว่าค่าส่วนใหญ่ตกอยู่ในช่วง 16…20°С และค่าต่างๆ นั้นมีค่าเฉลี่ยประมาณ 18°С นอกจากนี้ยังมีหางค่อนข้างกว้างในพื้นที่ข โอค่าที่สูงขึ้น

งานทดสอบ

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 10 8 5 5 9.
   1. สร้างอาร์เรย์ที่เรียงลำดับซึ่งมีข้อมูลที่ระบุ
   2. สร้างแผนภาพลำต้นและใบที่มีข้อมูลที่กำหนด
   3. การนำเสนอข้อมูลวิธีใดให้ข้อมูลได้ดีกว่ากัน ชี้แจงคำตอบของคุณ
   4. กำหนดมูลค่าที่การกระจายการชำระเงินรายเดือนสำหรับบริการธนาคารกระจุกตัว

คำตอบเพื่อทดสอบงาน

1. ดูชีต “Controll1” ของไฟล์ Excel และรูป 6. แผนภาพแบบก้านและใบให้ข้อมูลมากกว่าอาร์เรย์แบบเรียงลำดับ เนื่องจากทำให้เห็นภาพข้อมูลได้ดีกว่า ค่าเฉลี่ยจะอยู่ที่ประมาณ 22 เคล็ดลับในการทำงานคือการเลือกขั้นตอนสำหรับค่าลำตัว หากคุณเลือกจำนวนหลักสิบ (10, 20, 30) เป็นขั้นตอน แผนภาพ "ลำต้นและใบ" จะสูญเสียความชัดเจน

จัดเรียงอาร์เรย์คือกระบวนการกระจายองค์ประกอบทั้งหมดตามลำดับที่แน่นอน บ่อยครั้งสิ่งนี้มีประโยชน์ ตัวอย่างเช่น กล่องขาเข้าของคุณจะแสดงอีเมลตามเวลาที่ได้รับ อีเมลใหม่ถือว่ามีความเกี่ยวข้องมากกว่าอีเมลที่คุณได้รับเมื่อครึ่งชั่วโมง หนึ่งชั่วโมง สองหรือหนึ่งวันก่อน เมื่อคุณไปที่รายชื่อผู้ติดต่อ ชื่อมักจะเรียงตามตัวอักษรเพราะง่ายต่อการค้นหา กรณีทั้งหมดนี้เกี่ยวข้องกับการเรียงลำดับข้อมูลก่อนส่งออกจริง

การเรียงลำดับทำงานอย่างไร?

การเรียงลำดับข้อมูลสามารถทำให้การค้นหาภายในอาเรย์มีประสิทธิภาพมากขึ้น ไม่เพียงแต่สำหรับคนเท่านั้น แต่ยังรวมถึงคอมพิวเตอร์ด้วย ตัวอย่างเช่น พิจารณากรณีที่เราต้องค้นหาว่ามีชื่อใดปรากฏในรายชื่อหรือไม่ หากต้องการทราบ เราจำเป็นต้องตรวจสอบแต่ละองค์ประกอบของอาร์เรย์กับค่าของเรา การค้นหาอาร์เรย์ที่มีองค์ประกอบจำนวนมากอาจไม่มีประสิทธิภาพเกินไป (มีค่าใช้จ่ายสูง)

อย่างไรก็ตาม สมมติว่าอาร์เรย์ชื่อของเราเรียงลำดับตามตัวอักษร จากนั้นการค้นหาของเราเริ่มต้นด้วยอักษรตัวแรกของค่าของเราและลงท้ายด้วยตัวอักษรที่อยู่ถัดไปในตัวอักษร ในกรณีนี้ หากเราได้รับจดหมายฉบับนี้และไม่พบชื่อ เราก็รู้แน่นอนว่าไม่ได้อยู่ในอาร์เรย์ที่เหลือ เนื่องจากเราได้ส่งจดหมายของเราตามลำดับตัวอักษรแล้ว!

ไม่มีความลับว่ามีอัลกอริธึมที่ดีกว่าสำหรับการค้นหาภายในอาร์เรย์ที่เรียงลำดับ ด้วยการใช้อัลกอริธึมง่ายๆ เราสามารถค้นหาองค์ประกอบเฉพาะในอาร์เรย์ที่เรียงลำดับซึ่งมีองค์ประกอบ 1,000,000 รายการโดยใช้การเปรียบเทียบเพียง 20 รายการ! แน่นอนว่าข้อเสียก็คือการเรียงลำดับอาร์เรย์ที่มีองค์ประกอบจำนวนมากนั้นมีราคาค่อนข้างแพง และแน่นอนว่าไม่ได้ทำเพื่อคำค้นหาคำเดียว

ในบางกรณี การเรียงลำดับอาร์เรย์ทำให้การค้นหาไม่จำเป็น ตัวอย่างเช่น เรากำลังมองหาคะแนนที่ดีที่สุดของนักเรียนในการทดสอบ ถ้าอาร์เรย์ไม่ได้เรียงลำดับ เราจะต้องดูแต่ละองค์ประกอบของอาร์เรย์เพื่อหาคะแนนสูงสุด หากเรียงลำดับอาร์เรย์แล้ว คะแนนสูงสุดจะอยู่ในตำแหน่งแรกหรืออันดับสุดท้าย (ขึ้นอยู่กับวิธีการเรียงลำดับอาร์เรย์: จากน้อยไปหามากหรือจากมากไปหาน้อย) ดังนั้นเราจึงไม่จำเป็นต้องค้นหาเลย!

โดยทั่วไปการเรียงลำดับจะทำโดยการเปรียบเทียบคู่ขององค์ประกอบอาเรย์ซ้ำแล้วซ้ำอีกและแทนที่ค่าหากตรงตามเกณฑ์ที่กำหนด ลำดับการเปรียบเทียบองค์ประกอบเหล่านี้ขึ้นอยู่กับอัลกอริทึมการเรียงลำดับที่ใช้ เกณฑ์ประกอบด้วยวิธีการจัดเรียงอาร์เรย์ (เช่น ลำดับจากน้อยไปมากหรือจากมากไปน้อย)

ในการสลับสององค์ประกอบเราสามารถใช้ฟังก์ชันได้ มาตรฐาน::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 หลัก() int = 3 ; อินท์ ข = 5 ; มาตรฐาน::cout<< "Before swap: a = " << a << ", b = " << b << "\n" ; มาตรฐาน::swap(a, b); // สลับค่าของตัวแปร a และ b มาตรฐาน::cout<< "After swap: a = " << a << ", b = " << b << "\n" ;

ผลลัพธ์ของการรันโปรแกรมด้านบน:

ก่อนสลับ: a = 3, b = 5
หลังจากสลับ: a = 5, b = 3

หลังจากดำเนินการเปลี่ยนแล้ว ค่าของตัวแปร a และ b จะถูกสลับ

การเรียงลำดับอาร์เรย์โดยใช้วิธีการเลือก

มีหลายวิธีในการจัดเรียงอาร์เรย์ การเรียงลำดับอาร์เรย์ตามการเลือกอาจเป็นวิธีที่เข้าใจง่ายที่สุด แม้ว่าจะช้าที่สุดก็ตาม

สำหรับ การเรียงลำดับอาร์เรย์โดยเลือกจากองค์ประกอบที่เล็กที่สุดไปหาใหญ่ที่สุดดำเนินการตามขั้นตอนต่อไปนี้:

เริ่มต้นด้วยองค์ประกอบที่ดัชนี 0 เราจะค้นหาค่าที่น้อยที่สุดในอาร์เรย์

ค่าที่พบจะถูกสลับกับองค์ประกอบศูนย์

เราทำซ้ำขั้นตอนที่ 1 และหมายเลข 2 สำหรับดัชนีถัดไปในอาร์เรย์

กล่าวอีกนัยหนึ่ง เรามองหาองค์ประกอบที่เล็กที่สุดในอาร์เรย์และย้ายไปยังตำแหน่งแรก จากนั้นเรามองหาองค์ประกอบที่เล็กที่สุดเป็นอันดับสองและย้ายไปยังตำแหน่งที่สองรองจากองค์ประกอบที่เล็กที่สุดตัวแรก กระบวนการนี้จะดำเนินต่อไปจนกว่าอาร์เรย์จะหมดองค์ประกอบที่ไม่ได้เรียงลำดับ

นี่คือตัวอย่างการทำงานของอัลกอริทึมนี้ในอาร์เรย์ที่มี 5 องค์ประกอบ:

{ 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 หลัก() ความยาว int คงที่ = 5 ; // วนซ้ำแต่ละองค์ประกอบของอาร์เรย์ // (ยกเว้นอันสุดท้ายมันจะถูกจัดเรียงตามเวลาที่เราไปถึงแล้ว) < length - 1 ; ++ startIndex ) // ตัวแปร littlestIndex จะเก็บดัชนีของค่าที่น้อยที่สุดที่เราพบในการวนซ้ำนี้ // เริ่มต้นด้วยองค์ประกอบที่เล็กที่สุดในการวนซ้ำนี้ซึ่งเป็นองค์ประกอบแรก (ดัชนี 0) int smallestIndex = startIndex ; // จากนั้นมองหาองค์ประกอบที่มีขนาดเล็กกว่าในส่วนที่เหลือของอาร์เรย์ < length ; ++ currentIndex ) // ถ้าเราพบองค์ประกอบที่เล็กกว่าองค์ประกอบที่เล็กที่สุดของเรา ถ้า (อาร์เรย์ [ currentIndex ]< array [ smallestIndex ] ) //แล้วก็จำไว้. ดัชนีที่เล็กที่สุด = currentIndex ; // smallestIndex ตอนนี้เป็นองค์ประกอบที่เล็กที่สุด // สลับจำนวนที่น้อยที่สุดเริ่มต้นกับจำนวนที่เราพบ มาตรฐาน::swap(อาร์เรย์[startIndex],อาร์เรย์[smallestIndex]); // เมื่อจัดเรียงอาร์เรย์ทั้งหมดแล้ว ให้แสดงบนหน้าจอ สำหรับ (ดัชนี int = 0 ; ดัชนี< length ; ++ index ) มาตรฐาน::cout<< array [ index ] << " " ; กลับ 0 ;

ส่วนที่สับสนที่สุดของอัลกอริธึมนี้อยู่ในลูปอื่น (เรียกว่าลูปซ้อน) วงรอบนอก (startIndex) วนซ้ำผ่านองค์ประกอบทีละรายการ (ทีละรายการ) ในการวนซ้ำแต่ละครั้งของลูปภายนอก ลูปด้านใน (currentIndex) ถูกใช้เพื่อค้นหาองค์ประกอบที่เล็กที่สุดในบรรดาองค์ประกอบที่ยังคงอยู่ในอาร์เรย์ (เริ่มต้นที่ startIndex + 1) smallestIndex ติดตามดัชนีขององค์ประกอบที่เล็กที่สุดที่พบโดยวงใน จากนั้น SmallestIndex จะเปลี่ยนค่าจาก startIndex สุดท้าย ลูปด้านนอก (startIndex) จะผ่านองค์ประกอบนี้ และกระบวนการจะทำซ้ำ

เบาะแส:หากคุณมีปัญหาในการทำความเข้าใจวิธีการทำงานของโปรแกรมข้างต้น ให้ลองเขียนลงในกระดาษ เขียนองค์ประกอบเริ่มต้น (ไม่เรียงลำดับ) ของอาร์เรย์ในแนวนอนบนบรรทัดที่ด้านบนของแผ่นงาน วาดลูกศรเพื่อระบุว่าองค์ประกอบใดคือ startIndex , currentIndex และ SmallestIndex ในขณะนี้ วนซ้ำโปรแกรมด้วยตนเองแล้ววาดลูกศรใหม่เมื่อดัชนีเปลี่ยนแปลง หลังจากการวนรอบด้านนอกแต่ละครั้ง ให้ลากเส้นใหม่เพื่อแสดงสถานะปัจจุบันของอาร์เรย์ (ตำแหน่งขององค์ประกอบ)

การเรียงลำดับข้อความดำเนินการโดยใช้อัลกอริทึมเดียวกัน เพียงเปลี่ยนประเภทอาร์เรย์จาก -a เป็นและเริ่มต้นด้วยค่าที่เหมาะสม

มาตรฐาน::เรียงลำดับ()

เนื่องจากการทำงานของการเรียงลำดับอาร์เรย์เป็นเรื่องปกติมาก ไลบรารีมาตรฐาน C++ จึงมีฟังก์ชันการเรียงลำดับในตัว - มาตรฐาน::เรียงลำดับ()- ตั้งอยู่ในไฟล์ส่วนหัวของอัลกอริทึมและเรียกว่าดังนี้:

#รวม #รวม // สำหรับ 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::sort int หลัก() ความยาว int คงที่ = 5 ; อาร์เรย์ int [ความยาว] = (30, 50, 20, 10, 40); std::sort(อาร์เรย์, อาร์เรย์ + ความยาว) ; สำหรับ (int i = 0 ; i< length ; ++ i ) มาตรฐาน::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

เขียนโค้ดโปรแกรมใหม่จากคำบรรยาย "Sorting Arrays by Selection in C++" เพื่อให้การเรียงลำดับเสร็จสิ้นจากมากไปน้อย (จำนวนมากที่สุดไปหาน้อยที่สุด) แม้ว่าสิ่งนี้อาจดูซับซ้อนเมื่อมองแวบแรก แต่จริงๆ แล้วง่ายมาก

ตอบ #2

เพียงแค่เปลี่ยน:

ถ้า (อาร์เรย์< array)

ถ้า (อาร์เรย์ [ currentIndex ]< array [ smallestIndex ] )

ถ้า (อาร์เรย์ > อาร์เรย์)

ถ้า (อาร์เรย์ [ currentIndex ] > อาร์เรย์ [ smallestIndex ] )

SmallestIndex ควรเปลี่ยนชื่อเป็น LargestIndex ด้วย:

#รวม #รวม // สำหรับ 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) // นี่คือองค์ประกอบที่ใหญ่ที่สุดใหม่ในการวนซ้ำ mostIndex = currentIndex;< length; ++index) std::cout << array << " "; return 0; }

#รวม #รวม // สำหรับ std::swap ใน C ++ 11 ใช้ส่วนหัว int หลัก() ความยาว int คงที่ = 5 ; อาร์เรย์ int [ความยาว] = (30, 50, 20, 10, 40); ) // สลับหมายเลขเริ่มต้นของเราด้วยองค์ประกอบที่ใหญ่ที่สุดที่พบ std::swap(array, array); ) สำหรับ (ดัชนี int = 0; ดัชนี< length - 1 ; ++ startIndex ) // วนซ้ำทุกองค์ประกอบของอาร์เรย์ ยกเว้นองค์ประกอบสุดท้าย สำหรับ (int startIndex = 0 ; startIndex // largeIndex คือดัชนีขององค์ประกอบที่ใหญ่ที่สุดที่เราพบจนถึงตอนนี้ int largeIndex = startIndex ;< length ; ++ currentIndex ) // วนซ้ำแต่ละองค์ประกอบของอาร์เรย์โดยเริ่มจาก startIndex + 1 สำหรับ (int currentIndex = startIndex + 1 ; currentIndex // หากองค์ประกอบปัจจุบันมากกว่าองค์ประกอบที่ใหญ่ที่สุดของเรา ถ้า (อาร์เรย์ [ currentIndex ] > อาร์เรย์ [ hugeIndex ] ) // นี่คือองค์ประกอบที่ใหญ่ที่สุดใหม่ในการวนซ้ำนี้ ดัชนีที่ใหญ่ที่สุด = ดัชนีปัจจุบัน ; // สลับหมายเลขเริ่มต้นของเรากับองค์ประกอบที่ใหญ่ที่สุดที่พบ สำหรับ (ดัชนี int = 0 ; ดัชนี< length ; ++ index ) มาตรฐาน::cout<< array [ index ] << " " ; กลับ 0 ;

std::swap (อาร์เรย์ [ startIndex ] , อาร์เรย์ [ hugeIndex ] ) ;

// แสดงอาร์เรย์ที่เรียงลำดับบนหน้าจอ

ภารกิจที่ 3 งานนี้ยากขึ้นเล็กน้อยวิธีการเรียงลำดับองค์ประกอบง่ายๆ อีกวิธีหนึ่งก็คือ "การเรียงลำดับฟอง"(หรืออย่างอื่น

"การเรียงลำดับฟอง" - แนวคิดคือการเปรียบเทียบคู่ของค่าที่อยู่ใกล้เคียง และหากตรงตามเกณฑ์ที่กำหนด ค่าจากคู่นี้จะถูกสลับ และด้วยเหตุนี้องค์ประกอบจึงเกิด "ฟองสบู่" ที่ส่วนท้ายของอาร์เรย์ แม้ว่าจะมีหลายวิธีในการเพิ่มประสิทธิภาพการเรียงลำดับแบบบับเบิ้ล แต่สำหรับงานมอบหมายนี้ เราจะยังคงใช้เวอร์ชันที่ยังไม่ได้เพิ่มประสิทธิภาพเนื่องจากง่ายกว่า:

สำหรับการเรียงลำดับแบบบับเบิลเวอร์ชันที่ไม่ได้รับการปรับให้เหมาะสม ให้ดำเนินการตามขั้นตอนต่อไปนี้เพื่อ:

เรียงลำดับอาร์เรย์จากค่าที่น้อยที่สุดไปมากที่สุด

องค์ประกอบอาร์เรย์ที่ดัชนี 0 จะถูกเปรียบเทียบกับองค์ประกอบอาร์เรย์ที่ดัชนี 1 หากองค์ประกอบที่ดัชนี 0 มากกว่าองค์ประกอบที่ดัชนี 1 ค่าจะถูกสลับ

จากนั้นเราจะย้ายไปยังคู่ค่าถัดไป: องค์ประกอบที่ดัชนี 1 และองค์ประกอบที่ดัชนี 2 ไปเรื่อยๆ จนกระทั่งเราไปถึงจุดสิ้นสุดของอาร์เรย์

ทำซ้ำขั้นตอน #1 และขั้นตอน #2 จนกว่าอาร์เรย์ทั้งหมดจะถูกจัดเรียง

เขียนโปรแกรมที่จะเรียงลำดับอาร์เรย์ต่อไปนี้โดยใช้การเรียงลำดับแบบฟองตามกฎด้านบน:

ความยาว int คงที่ (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 ); for (int วนซ้ำ = 0; วนซ้ำ< 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 หลัก() เขียนโปรแกรมที่จะเรียงลำดับอาร์เรย์ต่อไปนี้โดยใช้การเรียงลำดับแบบฟองตามกฎด้านบน: ) ) // แสดงอาร์เรย์ที่เรียงลำดับบนหน้าจอสำหรับ (ดัชนี int = 0; ดัชนี อาร์เรย์ 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 ] ) ; } } // สลับหมายเลขเริ่มต้นของเรากับองค์ประกอบที่ใหญ่ที่สุดที่พบ แลกเปลี่ยน(สำหรับภายใน= 0 ; ภายใน< ดัชนี; ++ ภายใน) อาร์เรย์:: ความยาว<< ถ้า[ ภายใน] << " " ; ศาล0 ; }

กลับ

ภารกิจที่ 4

ใช้โซลูชันการปรับให้เหมาะสมสองรายการต่อไปนี้สำหรับอัลกอริธึมการเรียงลำดับแบบฟองที่คุณเขียนไว้ในงานก่อนหน้า: