การประเมินความซับซ้อนของเวลาโดยเฉลี่ยของอัลกอริธึมการทำฟองอากาศที่กำหนด

11

พิจารณารหัสเทียมของ bubbleort แบบนี้:

FOR i := 0 TO arraylength(list) STEP 1  
    switched := false
    FOR j := 0 TO arraylength(list)-(i+1) STEP 1
        IF list[j] > list[j + 1] THEN
            switch(list,j,j+1)
            switched := true
        ENDIF
    NEXT
    IF switched = false THEN
        break
    ENDIF
NEXT

อะไรคือแนวคิดพื้นฐานที่ฉันต้องจำไว้เพื่อประเมินความซับซ้อนของเวลาโดยเฉลี่ย ฉันได้ทำการคำนวณกรณีที่เลวร้ายที่สุดและดีที่สุดเรียบร้อยแล้ว แต่ฉันก็ตรึกตรองว่าจะประเมินความซับซ้อนเฉลี่ยของวงในเพื่อสร้างสมการ

สมการที่แย่ที่สุดคือ:

\sum_{i = 0}^{n} (\sum_{j = 0}^{n - (i + 1)} O (1) + O (1)) = O (\frac{n^{2}}{2} + \frac{n}{2}) = O (n^{2})

$\sum_{i=0}^n \left(\sum_{j=0}^{n -(i+1)}O(1) + O(1)\right) = O(\frac{n^2}{2} + \frac{n}{2}) = O(n^2)$

ที่ sigma ด้านในแทนวงด้านในและ sigma ด้านนอกแทนวงนอก ฉันคิดว่าฉันต้องเปลี่ยนทั้ง sigmas เนื่องจาก "if-then-break" - clause ซึ่งอาจส่งผลต่อ sigma ด้านนอก แต่เนื่องมาจาก if-clause ในลูปด้านในซึ่งจะส่งผลต่อการกระทำที่ทำระหว่างลูป (4 การกระทำ + 1 การเปรียบเทียบหากเป็นจริงมิฉะนั้นเพียง 1 การเปรียบเทียบ)

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

สำหรับสิ่งนี้ฉันคาดว่าคำสั่งใด ๆ จะมีความเป็นไปได้เดียวกัน

— ซิม
แหล่งที่มา

6

คุณต้องกำหนดความหมายโดยเฉลี่ยก่อน เนื่องจากอัลกอริทึมนั้นกำหนดไว้คุณจะต้องสมมติว่ามีการแจกแจงบางอย่างผ่านอินพุต

— Suresh

@Sim คุณสามารถแสดงให้เห็นว่าคุณคำนวณความซับซ้อนของเวลาที่เลวร้ายที่สุดได้อย่างไร? จากนั้นเราอาจได้รับแนวคิดเกี่ยวกับความซับซ้อนในกรณีของคุณ

— 0x0

ฉันหมายถึงเวลาเฉลี่ยในช่วงเวลาที่น่าจะเป็นไปได้มากที่สุด (หรือกล่าวอีกนัยหนึ่งว่า 'บริสุทธิ์' รุ่นคณิตศาสตร์: ค่าเฉลี่ยของทุกครั้งที่สังเกตเห็นการวิเคราะห์ทางสถิติ) ตัวอย่างเช่น quicksort มีค่าเฉลี่ยของ nlogn แม้ว่ากรณีที่เลวร้ายที่สุดคือ n ^ 2

— Sim

1

@Sim ในกรณีของการเรียงลำดับกรณีฟองเฉลี่ย = ความซับซ้อนของเวลากรณีที่เลวร้ายที่สุดหมายถึงความซับซ้อนของเวลากรณีเฉลี่ยยังเป็น

n^{2}

$n^2$

— 0x0

3

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

— Suresh

9

สำหรับรายการที่มีความยาวค่าเฉลี่ยมักจะหมายความว่าคุณต้องเริ่มต้นด้วยการแจกแจงแบบสม่ำเสมอในทุกพีชคณิตของ [ , .. , ]: นั่นจะเป็นรายการทั้งหมดที่คุณต้องพิจารณา $n$ $n!$ $1$ $n$

ความซับซ้อนเฉลี่ยของคุณจะเป็นผลรวมของจำนวนขั้นตอนสำหรับรายการทั้งหมดหารด้วย. $n!$

สำหรับรายการที่ระบุจำนวนขั้นตอนของอัลกอริทึมของคุณคือโดยที่คือระยะทางที่ยิ่งใหญ่ที่สุดระหว่างองค์ประกอบและตำแหน่งที่ถูกต้องของเขา (แต่เฉพาะเมื่อต้องเลื่อนไปทางซ้าย) นั่นคือi-x_i)) $(x_i)_i$ $nd$ $d$ $x_i$ $i$ $\max_i(\max(1,i-x_i))$

จากนั้นคุณทำคณิตศาสตร์: สำหรับแต่ละหาจำนวนของรายการที่มีระยะทางสูงสุดนี้โดยเฉพาะแล้วค่าที่คาดหวังของคือ: $d$ $c_d$ $d$

\frac{1}{n!} \sum_{d = 0}^{n} d c_{d}

$\frac1{n!}\ \sum_{d=0}^n{\ dc_d}$

และนั่นคือความคิดพื้นฐานโดยไม่ต้องส่วนที่ยากที่สุดคือการหาที่c_dอาจจะมีวิธีแก้ปัญหาที่ง่ายกว่า $c_d$

แก้ไข: เพิ่ม `คาดว่า '

— jmad
แหล่งที่มา

หากคุณพิจารณาการแจกแจงแบบปกติมีวิธีประมาณหรือไม่?

c_{d}

$c_d$

— Sim

คุณสามารถพูดได้เพราะคุณสามารถคลุกคลีทุกตำแหน่งของ [ , .. , ] และต่อท้ายที่แต่ท้ายสุดจะเล็กเพื่อพิสูจน์ค่าเฉลี่ย

c_{d} \geq (n + 1 - d) (d - 1)!

$c_d≥(n+1-d)(d-1)!$

2

$2$

d

$d$

1

$1$

n ²

$n²$

— jmad

19

จำได้ว่าเป็นคู่ (resp. ) จะกลับถ้าและ[เจ] $(A[i], A[j])$ $(i,j)$ $i < j$ $A[i] > A[j]$

สมมติว่าอัลกอริทึมของคุณมีการสลับหนึ่งครั้งสำหรับการกลับกันแต่ละครั้งเวลาทำงานของอัลกอริทึมของคุณจะขึ้นอยู่กับจำนวนการรุกราน

การคำนวณจำนวนผู้คาดหวังในการเปลี่ยนรูปแบบสุ่มที่สม่ำเสมอเป็นเรื่องง่าย:

Letจะเปลี่ยนแปลงและให้จะย้อนกลับของPตัวอย่างเช่นถ้าแล้ว4,3,1,2 $P$ $R(P)$ $P$ $P = 2,1,3,4$ $R(P) = 4,3,1,2$

สำหรับคู่ของดัชนีแต่ละมีความผกผันในตรงหนึ่งทั้งหรือ(P) $(i,j)$ $P$ $R(P)$

เนื่องจากจำนวนคู่ทั้งหมดคือและจำนวนรวมและแต่ละคู่จะกลับด้านครึ่งหนึ่งของการเรียงสับเปลี่ยนสมมติว่าการเรียงสับเปลี่ยนทั้งหมดมีแนวโน้มเท่ากันจำนวนการคาดการณ์ของการแลกเปลี่ยนคือ: $n(n-1)/2$

\frac{n (n - 1)}{4}

$\frac{n(n-1)}{4}$

— โจ
แหล่งที่มา

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

— Sim

คุณจะได้รับการเปรียบเทียบด้วยการแลกเปลี่ยนและที่สำคัญที่สุดการสลับอย่างเดียวสามารถลดจำนวนผู้รุกรานได้มากที่สุด

— jmad

ไม่ใช่ทุกการเปรียบเทียบจะส่งผลให้เกิดการสลับถ้า if-clause เป็นเท็จจะไม่ทำการผกผัน

— Sim

@rgrig หากคุณมีตัวอย่างให้ฉันจะแก้ไขคำตอบของฉัน

— Joe

@Joe: ฉันลบความคิดเห็นของฉัน มันผิด

— rgrig

2

จำนวนการสลับ <จำนวนการวนซ้ำ (ทั้งในสถานการณ์ที่เหมาะสมและสถานการณ์ฟองสบู่ธรรมดา)

Number of Inversions = จำนวนของการแลกเปลี่ยน

ดังนั้นจำนวนการทำซ้ำ> $\frac{n(n-1)}{4}$

ดังนั้นความซับซ้อนกรณีเฉลี่ยอยู่ที่ 2) แต่เนื่องจากกรณีเฉลี่ยลาดเทเกินกรณีที่เลวร้ายที่สุดที่เราได้รับว่ามันเป็น , $\omega(n^2)$ $O(n^2)$

สิ่งนี้ทำให้เรา: เวลาเฉลี่ย = $\theta(n^2)$

(ความซับซ้อนของเวลา = จำนวนการวนซ้ำของการวนซ้ำ> จำนวนการสลับ)

— kushj
แหล่งที่มา

0

ในเอกสารนี้ความซับซ้อนของเวลาเฉลี่ยของการเรียงลำดับฟองถึง O (nlog (n))! http://algo.inria.fr/flajolet/Publications/ViFl90.pdf

— user84630
แหล่งที่มา

1

ที่ไม่เป็นความจริง. พวกเขาพิสูจน์ผลมาจากนูแสดงให้เห็นว่าจำนวนที่คาดหวังของการเปรียบเทียบเป็นประมาณ2/2

n^{2} / 2

$n^2/2$

— Yuval Filmus