ทำไมการผสาน O (log n)

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

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

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

ความซับซ้อนของการจัดเรียงผสานคือ O (nlogn) และ NOT O (logn)

การเรียงลำดับผสานเป็นอัลกอริทึมการแบ่งและพิชิต คิดในแง่ของ 3 ขั้นตอน -

1. ขั้นตอนการหารคำนวณจุดกึ่งกลางของแต่ละอาร์เรย์ย่อย แต่ละขั้นตอนนี้ใช้เวลาเพียง O (1)
2. ขั้นตอนการพิชิตซ้ำเรียงสอง subarrays ของ n / 2 (สำหรับคู่ n) แต่ละองค์ประกอบ
3. ขั้นตอนการผสานผสานองค์ประกอบที่ใช้เวลา O (n)

ทีนี้สำหรับขั้นตอนที่ 1 และ 3 คือระหว่าง O (1) และ O (n), O (n) จะสูงกว่า ลองพิจารณาขั้นตอนที่ 1 และ 3 ใช้เวลาทั้งหมด O (n) สมมติว่ามันเป็น cn สำหรับค่าคงที่ c

ดำเนินการตามขั้นตอนเหล่านี้กี่ครั้ง

สำหรับสิ่งนี้ให้ดูที่ต้นไม้ด้านล่าง - สำหรับแต่ละระดับจากบนลงล่างระดับ 2 เรียกวิธีการรวมใน 2 อาร์เรย์ย่อยที่มีความยาว n / 2 แต่ละรายการ ความซับซ้อนที่นี่คือ 2 * (cn / 2) = cn ระดับ 3 เรียกวิธีการรวมใน 4 อาร์เรย์ย่อยที่มีความยาว n / 4 แต่ละวิธี ความซับซ้อนที่นี่คือ 4 * (cn / 4) = cn และอื่น ๆ ...

ตอนนี้ความสูงของต้นไม้นี้คือ (logn + 1) สำหรับ n ที่กำหนด ดังนั้นความซับซ้อนโดยรวมคือ (logn + 1) * (cn) นั่นคือ O (nlogn) สำหรับอัลกอริทึมการเรียงลำดับการผสาน

เครดิตรูปภาพ: Khan Academy

Merge Sort เป็นอัลกอริทึมแบบเรียกซ้ำและความซับซ้อนของเวลาสามารถแสดงได้ดังนี้

T (n) = 2T (n / 2) + ɵ (n)

การเกิดซ้ำข้างต้นสามารถแก้ไขได้โดยใช้วิธีการทำซ้ำต้นไม้หรือวิธีการต้นแบบ มันตกอยู่ในกรณีที่ II ของวิธีการหลักและวิธีแก้ปัญหาของการเกิดซ้ำคือɵ (n log n)

ความซับซ้อนของเวลาในการรวมการเรียงลำดับคือɵ (nLogn) ในทั้ง 3 กรณี (แย่ที่สุด, ปานกลางและดีที่สุด) เนื่องจากการเรียงลำดับการผสานจะแบ่งอาร์เรย์ในสองส่วนเสมอและใช้เวลาเชิงเส้นเพื่อผสานสองครึ่ง

มันแบ่งอาร์เรย์อินพุตในสองส่วนเรียกตัวเองว่าสำหรับทั้งสองส่วนแล้วรวมทั้งสองแบ่งครึ่ง ฟังก์ชันการรวม () ใช้สำหรับการรวมสองครึ่ง การผสาน (arr, l, m, r) เป็นกระบวนการหลักที่สมมติว่า arr [l..m] และ arr [m + 1.r] ได้รับการจัดเรียงและผสานทั้งสองอาร์เรย์ย่อยที่เรียงลำดับไว้เข้าด้วยกัน ดูการติดตั้ง C ต่อไปนี้สำหรับรายละเอียด

MergeSort(arr[], l,  r)
If r > l
     1. Find the middle point to divide the array into two halves:  
             middle m = (l+r)/2
     2. Call mergeSort for first half:   
             Call mergeSort(arr, l, m)
     3. Call mergeSort for second half:
             Call mergeSort(arr, m+1, r)
     4. Merge the two halves sorted in step 2 and 3:
             Call merge(arr, l, m, r)

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

อัลกอริธึมการเรียงตามการเปรียบเทียบมีขอบเขตที่ต่ำกว่า𝞨(n*log(n))ซึ่งหมายความว่าเป็นไปไม่ได้ที่จะมีอัลกอริธึมการเรียงลำดับตามการเปรียบเทียบที่มีO(log(n))ความซับซ้อนของเวลา

O(n*log(n))โดยวิธีการที่ผสานการเรียงลำดับคือ คิดอย่างนี้

[ a1,a2,         a3,a4,         a5,a6,          a7,a8     .... an-3,an-2,     an-1, an ] 
   \ /            \  /           \ /             \  /            \  /            \  /    
    a1'            a3'            a5'             a7'            an-3'           an-1'    
      \            /                \             /                 \             /
            a1''                          a5''                       an-3''
             \                             /                         /
                          a1'''                                     /
                           \
                                              a1''''

นี่ดูเหมือนต้นไม้ไบนารีที่ตรงกันข้าม

nให้ขนาดการป้อนข้อมูลที่เป็น

แต่ละa_nรายการแสดงองค์ประกอบ บรรทัดแรกa_nมีองค์ประกอบเดียวเท่านั้น

ในแต่ละระดับผลรวมของต้นทุนการรวมโดยเฉลี่ยคือn(มีกรณีมุมซึ่งมีค่าใช้จ่ายต่ำกว่า [1]) log_2(n)และความสูงของต้นไม้คือ

O(n*log_2(n))ดังนั้นความซับซ้อนเวลาของการผสานการเรียงลำดับคือ

[1] หากการเรียงลำดับในรายการที่เรียงลำดับแล้วซึ่งเรียกว่ากรณีที่ดีที่สุด n/2 + n/4 + n/8 + .... + 1 = 2^log_2(n) -1 ~ O(n)ค่าใช้จ่ายลดลง (สมมติว่าความยาวnคือพลังของสอง)

การเรียงลำดับเป็นปัญหา NP-Complete ในวิทยาการคอมพิวเตอร์ (ปัญหาที่ไม่ใช่พหุนาม) ซึ่งหมายความว่าหากไม่ได้รับการพิสูจน์ทางคณิตศาสตร์คุณจะไม่สามารถลงไปต่ำกว่า O (n log n) เมื่อเรียงลำดับรายการองค์ประกอบ

ตรวจสอบบทความนี้ใน Wikipedia ( https://en.wikipedia.org/wiki/P_versus_NP_problem )

โดยทั่วไปจนถึงตอนนี้ไม่มีใครจัดการเพื่อพิสูจน์ว่า (P == NP) และถ้าคุณทำคุณจะกลายเป็นเศรษฐีครั้งที่สองคุณเริ่มสงครามโลกครั้งที่สามเนื่องจากความจริงที่ว่าคุณจะสามารถทำลายกลไกความปลอดภัยคีย์ผับ / ส่วนตัวที่ใช้ทั้งหมด ทุกที่ในปัจจุบัน :)