การเรียงลำดับการแทรกเทียบกับอัลกอริทึมการเรียงลำดับฟอง

ฉันกำลังพยายามทำความเข้าใจอัลกอริทึมการจัดเรียงบางอย่าง แต่ฉันกำลังดิ้นรนเพื่อให้เห็นความแตกต่างของอัลกอริทึมการเรียงลำดับฟองและการเรียงลำดับการแทรก

ฉันรู้ว่าทั้งคู่คือ O (n ² ) แต่สำหรับฉันแล้วสำหรับฉันแล้วว่าการเรียงฟองเพียงแค่ฟองค่าสูงสุดของอาร์เรย์ไปที่ด้านบนสำหรับแต่ละรอบในขณะที่การเรียงลำดับการแทรกจะจมค่าต่ำสุดไปที่ด้านล่างของแต่ละรอบ พวกเขาไม่ได้ทำสิ่งเดียวกัน แต่ไปคนละทาง?

สำหรับการเรียงลำดับการแทรกจำนวนการเปรียบเทียบ / การแลกเปลี่ยนที่เป็นไปได้จะเริ่มต้นที่ศูนย์และเพิ่มขึ้นทุกครั้ง (เช่น 0, 1, 2, 3, 4, ... , n) แต่สำหรับการเรียงฟองลักษณะเดียวกันนี้จะเกิดขึ้น แต่ในตอนท้ายของ การเรียงลำดับ (เช่น n, n-1, n-2, ... 0) เนื่องจากการจัดเรียงฟองไม่จำเป็นต้องเปรียบเทียบกับองค์ประกอบสุดท้ายอีกต่อไปเมื่อมีการจัดเรียง

สำหรับทั้งหมดนี้ดูเหมือนว่าจะมีความเห็นเป็นเอกฉันท์ว่าการเรียงลำดับการแทรกจะดีกว่าโดยทั่วไป ใครช่วยบอกทีว่าทำไม?

แก้ไข: ฉันสนใจเป็นหลักในความแตกต่างของวิธีการทำงานของอัลกอริทึมไม่ใช่ประสิทธิภาพหรือความซับซ้อนแบบไม่แสดงอาการมากนัก

ในการเรียงฟองในการวนซ้ำคุณมีการวนซ้ำภายใน ni-1 (n ^ 2) / 2 ทั้งหมด แต่ในการเรียงลำดับการแทรกคุณมีการวนซ้ำสูงสุดของฉันในขั้นตอนที่ฉันทำ แต่ฉัน / 2 โดยเฉลี่ยเนื่องจากคุณสามารถหยุดวงในได้ ก่อนหน้านี้หลังจากที่คุณพบตำแหน่งที่ถูกต้องสำหรับองค์ประกอบปัจจุบัน คุณจึงมี (ผลรวมจาก 0 ถึง n) / 2 ซึ่งเป็น (n ^ 2) / 4 รวม;

นั่นเป็นเหตุผลว่าทำไมการเรียงลำดับการแทรกจึงเร็วกว่าการเรียงลำดับฟอง

เรียงลำดับการแทรก

หลังจากฉันทำซ้ำองค์ประกอบiแรกจะถูกเรียงลำดับ

ในการวนซ้ำแต่ละครั้งองค์ประกอบถัดไปจะถูกฟองผ่านส่วนที่เรียงลำดับจนกว่าจะถึงจุดที่ถูกต้อง:

sorted  | unsorted
1 3 5 8 | 4 6 7 9 2
1 3 4 5 8 | 6 7 9 2

4 จะถูกเติมลงในส่วนที่เรียงลำดับ

รหัสเทียม:

for i in 1 to n
    for j in i downto 2
        if array[j - 1] > array[j]
            swap(array[j - 1], array[j])
        else
            break

เรียงฟอง

หลังจากฉันทำซ้ำองค์ประกอบสุดท้ายของฉันจะใหญ่ที่สุดและเรียงลำดับ

ในการทำซ้ำแต่ละครั้งให้ลอดผ่านส่วนที่ไม่เรียงลำดับเพื่อหาค่าสูงสุด

unsorted  | biggest
3 1 5 4 2 | 6 7 8 9
1 3 4 2 | 5 6 7 8 9

5 เป็นฟองออกจากส่วนที่ไม่ได้เรียงลำดับ

รหัสเทียม:

for i in 1 to n
    for j in 1 to n - i
         if array[j] > array[j + 1]
             swap(array[j], array[j + 1])

โปรดทราบว่าการใช้งานทั่วไปจะสิ้นสุดลงก่อนกำหนดหากไม่มีการทำ swaps ในระหว่างการวนซ้ำรอบนอก (เนื่องจากนั่นหมายความว่าอาร์เรย์ถูกจัดเรียง)

ความแตกต่าง

ในองค์ประกอบการจัดเรียงการแทรกจะถูกทำให้เป็นฟองในส่วนที่เรียงลำดับในขณะที่ในการเรียงลำดับฟองจำนวนสูงสุดจะถูกปัดออกจากส่วนที่ไม่ได้เรียงลำดับ

ความแตกต่างอีกอย่างฉันไม่เห็นที่นี่:

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

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

ซึ่งทำให้การกำหนดมูลค่าน้อยลงมากเช่นกัน

นี่ไม่ใช่ผลประโยชน์ด้านความเร็วที่แข็งแกร่งที่สุด แต่ฉันคิดว่ามันสามารถกล่าวถึงได้

ฉันหวังว่าฉันจะแสดงออกว่าเข้าใจได้ถ้าไม่ขอโทษฉันไม่ใช่คนอังกฤษ

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

ฉันรู้สึกว่านี่จะเร็วกว่าn log(n)อัลกอริทึมทั่วไปอื่น ๆ เนื่องจากความซับซ้อนจะเป็นn*(n log(n))เช่นการอ่าน / การจัดเก็บแต่ละค่าจากสตรีม ( O(n)) แล้วเรียงลำดับค่าทั้งหมด ( O(n log(n))) ส่งผลให้O(n^2 log(n))

ในทางตรงกันข้ามการใช้ Insert Sort จำเป็นต้องO(n)อ่านค่าจากสตรีมและO(n)ใส่ค่าไปยังตำแหน่งที่ถูกต้องดังนั้นจึงเป็นO(n^2)เพียง ข้อดีอื่น ๆ คือคุณไม่จำเป็นต้องใช้บัฟเฟอร์ในการจัดเก็บค่าคุณจัดเรียงในปลายทางสุดท้าย

Bubble Sort ไม่ได้ออนไลน์ (ไม่สามารถจัดเรียงสตรีมอินพุตโดยไม่รู้ว่าจะมีกี่รายการ) เนื่องจากไม่ได้ติดตามองค์ประกอบที่เรียงลำดับสูงสุดทั่วโลก เมื่อใส่รายการคุณจะต้องเริ่มการเดือดตั้งแต่ต้น

การเรียงลำดับฟองดีจะดีกว่าการเรียงลำดับเฉพาะเมื่อมีคนมองหาองค์ประกอบ k อันดับต้น ๆ จากรายการจำนวนมากเช่นในการเรียงลำดับฟองหลังจากการวนซ้ำ k คุณจะได้องค์ประกอบ k อันดับต้น ๆ อย่างไรก็ตามหลังจากการเรียงลำดับ k ซ้ำในการเรียงลำดับการแทรกจะทำให้มั่นใจได้ว่าองค์ประกอบ k เหล่านั้นถูกจัดเรียงเท่านั้น

แม้ว่าทั้งสองประเภทจะเป็น O (N ^ 2) ค่าคงที่ที่ซ่อนอยู่มีขนาดเล็กกว่ามากในการเรียงลำดับการแทรกค่าคงที่ซ่อนหมายถึงจำนวนจริงของการดำเนินการดั้งเดิมที่ดำเนินการ

เมื่อการเรียงลำดับการแทรกมีเวลาทำงานที่ดีขึ้น?

1. Array เกือบจะเรียงลำดับแล้วสังเกตได้ว่าการเรียงลำดับการแทรกจะดำเนินการน้อยกว่าในกรณีนี้มากกว่าการเรียงแบบฟอง
2. อาร์เรย์มีขนาดค่อนข้างเล็ก: การจัดเรียงการแทรกคุณย้ายองค์ประกอบไปรอบ ๆ เพื่อใส่องค์ประกอบปัจจุบันสิ่งนี้จะดีกว่าการเรียงฟองหากมีจำนวนองค์ประกอบน้อย

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

จำนวนการแลกเปลี่ยนในการทำซ้ำแต่ละครั้ง

• การเรียงลำดับการแทรกสามารถสลับได้สูงสุด 1 ครั้งในการวนซ้ำแต่ละครั้งแลกเปลี่ยนในแต่ละซ้ำ
• Bubble-sort จะทำการแลกเปลี่ยน 0 ถึง n ในการทำซ้ำแต่ละครั้ง

การเข้าถึงและเปลี่ยนส่วนที่เรียงลำดับ

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

ออนไลน์หรือไม่

• การเรียงลำดับการแทรกออนไลน์อยู่ นั่นหมายความว่าการเรียงลำดับการแทรกจะรับอินพุตทีละรายการก่อนที่จะวางในตำแหน่งที่เหมาะสม ไม่จำเป็นต้องเปรียบเทียบเท่านั้นadjacent-inputsมันไม่ได้มีการเปรียบเทียบเท่านั้น
• Bubble-sort ไม่ออนไลน์ ไม่ทำงานหนึ่งอินพุตในแต่ละครั้ง จัดการกลุ่มของอินพุต (ถ้าไม่ใช่ทั้งหมด) ในการวนซ้ำแต่ละครั้ง Bubble-sort จะเปรียบเทียบและสลับadjacent-inputsในการวนซ้ำแต่ละครั้งเท่านั้น

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

เรียงลำดับการแทรก:

1. ในการสลับการเรียงลำดับการแทรกไม่จำเป็นต้องใช้

2. ความซับซ้อนของเวลาในการเรียงลำดับการแทรกคือΩ (n) สำหรับกรณีที่ดีที่สุดและกรณีที่เลวร้ายที่สุด O (n ^ 2)

3. ไม่มีความซับซ้อนเมื่อเทียบกับการเรียงฟอง

4. ตัวอย่าง: ใส่หนังสือในห้องสมุดจัดเรียงการ์ด

การจัดเรียงฟอง: 1. ต้องมีการสลับในการจัดเรียงฟอง

2. ความซับซ้อนของเวลาในการเรียงฟองคือΩ (n) สำหรับกรณีที่ดีที่สุดและกรณีที่เลวร้ายที่สุด O (n ^ 2)

3. ซับซ้อนมากขึ้นเมื่อเทียบกับการเรียงลำดับการแทรก

การเรียงลำดับการแทรกสามารถกลับมาเป็น " มองหาองค์ประกอบที่ควรอยู่ในตำแหน่งแรก (ต่ำสุด) สร้างช่องว่างโดยเลื่อนองค์ประกอบถัดไปและวางไว้ที่ตำแหน่งแรกดีตอนนี้ดูองค์ประกอบซึ่งควรอยู่ที่ 2 ... "ไปเรื่อย ๆ ...

การจัดเรียงบับเบิ้ลจะทำงานแตกต่างกันซึ่งสามารถกลับมาทำงานต่อได้โดย " ตราบใดที่ฉันพบสององค์ประกอบที่อยู่ติดกันซึ่งเรียงลำดับไม่ถูกต้องฉันก็สลับมัน "