วิธีเขียนโค้ด Python QuickSort

Python QuickSort เลือกองค์ประกอบ pivot และแยกองค์ประกอบของ อาร์เรย์ เป็นสองใหม่ อาร์เรย์ ส. ตัวเลขที่สูงกว่าเดือยรวมกันเป็นหนึ่ง อาร์เรย์ ; ตัวเลขที่ต่ำกว่าเดือยเข้าไปอีก แต่ละ อาร์เรย์ ถูกจัดเรียงแล้วทั้งหมด อาร์เรย์ รวมเป็นหนึ่งเดียว

วิธีเขียนโค้ด Python QuickSort

มีอัลกอริธึมการเรียงลำดับมากมายที่คุณสามารถใช้เพื่อเรียงลำดับรายการในการเขียนโปรแกรม มีการเรียงลำดับการแทรก Python การเรียงลำดับแบบฟองและอื่น ๆ QuickSort เป็นหนึ่งในประเภทที่พบบ่อยที่สุด

ในคู่มือนี้ เราจะพูดถึงว่า QuickSorts คืออะไรและทำงานอย่างไร เราจะอธิบายตัวอย่าง Python QuickSort เพื่อให้คุณได้เรียนรู้วิธีการใช้งาน

เพื่อไม่ให้เป็นการเสียเวลา มาเริ่มกันเลย!

Python QuickSort คืออะไร

อัลกอริทึม Python QuickSort แบ่งอาร์เรย์ออกเป็นอาร์เรย์ย่อย อัลกอริทึมนี้เรียกอาร์เรย์ย่อยเหล่านี้แบบเรียกซ้ำเพื่อเรียงลำดับแต่ละองค์ประกอบในรายการ เนื้อหาของอาร์เรย์ย่อยถูกกำหนดโดยองค์ประกอบ pivot ที่ไม่ได้ย้ายไปยังอาร์เรย์ย่อยใหม่

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

ใน QuickSort งานย่อยคือการตั้งค่า pivot สำหรับแต่ละรายการย่อยและจัดลำดับองค์ประกอบตามค่าที่สัมพันธ์กับ pivot

ฉันควรใช้ Python QuickSort เมื่อใด

QuickSort มีประโยชน์เมื่อเวลามีความซับซ้อน เนื่องจาก QuickSort ใช้พื้นที่หน่วยความจำน้อยกว่าอัลกอริธึมอื่นๆ ซึ่งช่วยเพิ่มประสิทธิภาพได้

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

คุณควรใช้ QuickSort หากคุณคุ้นเคยกับการเรียกซ้ำของ Python เนื่องจากอัลกอริทึม QuickSort ขึ้นอยู่กับฟังก์ชันแบบเรียกซ้ำ

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

QuickSort ทำงานอย่างไร

QuickSort เลือกองค์ประกอบเพื่อใช้เป็นเดือย นี่อาจเป็นองค์ประกอบใดก็ได้ในรายการ สำหรับบทช่วยสอนนี้ เราจะเลือกรายการสุดท้ายในรายการ (3)

QuickSort จะเปรียบเทียบค่าของ pivot กับทุกตัวเลขเมื่อเราวนซ้ำรายการในรายการ หากรายการใดมีค่ามากกว่าหมายเลขเดือย เราจะย้ายตัวเลขหลังเดือย มิฉะนั้น เราจะย้ายตัวเลขก่อนเดือย:

ค่า 3 ได้ย้ายลงรายการของเรา รายการทั้งหมดที่น้อยกว่า 3 ย้ายไปทางซ้าย ค่าทั้งหมดที่มากกว่าสามย้ายไปทางขวา

อาร์เรย์ Python ของเราแบ่งออกเป็นสองส่วน:รายการมากกว่า pivot และรายการน้อยกว่า pivot

เมื่อกระบวนการนี้เริ่มต้นขึ้น pivot ใหม่จะเริ่มขึ้นที่แต่ละส่วน เดือยนี้เริ่มต้นแยกจากกันและใช้อัลกอริธึมเดียวกับด้านบน อันดับแรก เราจะตั้งค่า pivot ซึ่งเท่ากับค่าสุดท้ายในแต่ละรายการ:

ต่อไป เราจะย้ายค่าทั้งหมดที่มากกว่าเดือยไปทางขวาของเดือย เราย้ายค่าทั้งหมดที่น้อยกว่าเดือยไปทางซ้าย

กระบวนการนี้จะดำเนินต่อไปจนกว่าเราจะจัดเรียงรายการของเรา:

อาร์เรย์สุดท้ายของเรามีลักษณะดังนี้:

ตัวอย่าง Python QuickSort

QuickSort ต้องการสองฟังก์ชัน:ฟังก์ชัน pivot และฟังก์ชัน QuickSort

มาเริ่มกันที่ฟังก์ชันพาร์ติชั่นกัน การดำเนินการนี้จะแบ่งพาร์ติชั่นหรือเตรียมอาร์เรย์ตามค่าขององค์ประกอบเดือย

ฟังก์ชันพาร์ทิชันของเราจะ:

1. เลือกองค์ประกอบเดือย
2. ย้ายรายการทั้งหมดที่มากกว่าเดือยไปทางขวาของเดือย
3. ย้ายรายการทั้งหมดที่น้อยกว่าเดือยไปทางซ้ายของเดือย

โปรแกรม QuickSort Python

มาเขียนโปรแกรมที่ใช้อัลกอริทึมนี้กันเถอะ:

def prepare(numbers, low, high):pivot =numbers[high] item =low - 1 for i in range(low, high):if numbers[i] <=pivot:item =item + 1 (ตัวเลข) [item], numbers[i]) =(numbers[i], numbers[item]) (numbers[item + 1], numbers[high]) =(numbers[high], numbers[item + 1]) ส่งคืนสินค้า +1

ขั้นแรก เราเลือกองค์ประกอบเดือย ซึ่งเท่ากับจำนวนสูงสุดในรายการของเรา

ต่อไป เราวนซ้ำรายการทั้งหมดในรายการโดยใช้ Python for loop หากตัวเลขน้อยกว่าหรือเท่ากับเดือย จะถูกย้ายไปทางซ้ายของเดือย มิฉะนั้นจะไปทางขวาของเดือย

ฟังก์ชัน Python ของเราจะคืนค่าสูงใหม่ ค่าสูงใหม่เท่ากับรายการ + 1

ต่อไป เราต้องเรียกใช้อัลกอริทึมของเรา เราสามารถทำได้โดยการเขียนฟังก์ชันแยก:

def quick_sort(numbers, low, high):if low  

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

 ต่อไป ฟังก์ชันของเราเรียก prepare() กระบวนการ. ซึ่งจะระบุตัวชี้สำหรับเดือยและย้ายรายการไปยังตำแหน่งที่ถูกต้อง
 

 ฟังก์ชันของเราเรียก quick_sort() วิธีสองครั้ง ครั้งแรก เราเรียกใช้ QuickSort บนองค์ประกอบทางด้านซ้ายของเดือย ครั้งที่สอง เราเรียกใช้ QuickSort กับองค์ประกอบทางด้านขวาของเดือย ดังนั้น ฟังก์ชันของเราจึงเรียกซ้ำเพราะมันเรียกตัวเองว่า
 

 สิ่งนี้จะดำเนินต่อไปจนกว่าทุกรายการในรายการจะถูกจัดเรียง
 
การเขียนวิธีการหลัก
 

 มาเขียนโปรแกรมหลักที่กำหนดรายการที่จะเรียงลำดับกันเถอะ:
 
values ​​=[8, 4, 5, 2, 1, 3]total_values ​​=len(values)quick_sort(values, 0, total_values ​​- 1)print(values)
 

 อันดับแรก เราระบุรายการค่าที่จะจัดเรียง เราใช้เมธอด Python len() เพื่อคำนวณความยาวของรายการค่าของเรา ต่อไป เราเรียก quick_sort() วิธีการ
 

 เราส่ง "ค่า" เป็นตัวเลขที่เราต้องการจัดเรียง จากนั้นเราจะผ่าน 0 เป็นจำนวนที่ต่ำ ความยาวของ "ค่า" ลบ 1 คือค่าสูงที่เราระบุ ค่าสูงคือความยาวของค่าลบ 1 เนื่องจากรายการแรกในรายการมีหมายเลขดัชนี 0
 

 มาลองรันโปรแกรมของเรากัน:
 
[1, 2, 3, 4, 5, 8]
 

 รหัสของเราส่งคืนรายการที่เรียงลำดับ! เราทำได้. ตบหลังตัวเองหน่อย QuickSort ไม่ใช่เรื่องง่ายที่จะเข้าใจหรือนำไปใช้
 
ภาพรวมความซับซ้อน
 

 โดยเฉลี่ย อัลกอริธึมนี้จะทำงานที่ O(n* log n) สิ่งนี้จะเกิดขึ้นเมื่อองค์ประกอบ pivot ไม่ใช่องค์ประกอบที่ยิ่งใหญ่ที่สุดหรือเล็กที่สุด และเมื่อองค์ประกอบ pivot ไม่ได้อยู่ใกล้องค์ประกอบตรงกลาง
 

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

 ความซับซ้อนของเคสที่ดีที่สุดสำหรับอัลกอริทึมนี้คือ O(n* log n) สิ่งนี้จะเกิดขึ้นเมื่อองค์ประกอบ pivot เท่ากับองค์ประกอบกลางหรือใกล้กับองค์ประกอบตรงกลาง
 

 หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับความซับซ้อนของอัลกอริทึม โปรดดูคำแนะนำเกี่ยวกับ Big O Notation
 
บทสรุป
 

 Python QuickSorts ใช้การเรียกซ้ำเพื่อแยกรายการออกเป็นรายการย่อยๆ แล้วจึงจัดเรียง แต่ละรายการจะจัดเรียงตามองค์ประกอบเดือย องค์ประกอบที่มากกว่าเดือยจะถูกย้ายไปทางขวา องค์ประกอบที่เล็กกว่าจะถูกย้ายไปทางซ้ายของเดือย
 

 สำหรับคำแนะนำเกี่ยวกับแหล่งข้อมูลการเรียนรู้ Python หลักสูตรออนไลน์ และหนังสือชั้นนำ โปรดอ่านคู่มือ How to Learn Python ที่ครอบคลุม