มีอัลกอริทึม "การเรียงลำดับ" ซึ่งส่งกลับค่าการสุ่มเมื่อใช้ตัวเปรียบเทียบแบบพลิกเหรียญหรือไม่?

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

มีอัลกอริทึมการเรียงลำดับแบบอิงซึ่งจะขึ้นอยู่กับการนำไปใช้ของตัวเปรียบเทียบ:

1. คืนองค์ประกอบในลำดับที่เรียงเมื่อใช้ตัวเปรียบเทียบที่แท้จริง (นั่นคือการเปรียบเทียบทำตามที่เราคาดหวังในอัลกอริทึมการเรียงลำดับมาตรฐาน)
2. ส่งคืนการเปลี่ยนแปลงการสุ่มอย่างสม่ำเสมอขององค์ประกอบเมื่อตัวเปรียบเทียบถูกแทนที่ด้วยการพลิกเหรียญอย่างยุติธรรม (นั่นคือกลับx < y = trueด้วยความน่าจะเป็น 1/2 โดยไม่คำนึงถึงค่าของ x และ y)

รหัสสำหรับอัลกอริทึมการเรียงลำดับจะต้องเหมือนกัน มันเป็นเพียงรหัสในการเปรียบเทียบ "กล่องดำ" ที่ได้รับอนุญาตให้เปลี่ยน

อัลกอริธึมที่กำหนดขึ้นเอง (โดยไม่มีตัวเปรียบเทียบ) ต่อไปนี้ใช้สำหรับ tuple อินพุต $(a_1,\dots,a_n)$:

1. ทำการสับเปลี่ยน Fisher-Yatesโดยใช้เครื่องมือเปรียบเทียบกับคู่คงที่บางตัว (พูด$a_1 < a_2$) เป็นการพลิกเหรียญ (ทำการสุ่มตัวอย่างปฏิเสธการยอมรับ) ถ้าตัวเปรียบเทียบเอาท์พุท$1$ ในครั้งแรกให้ใช้มันคว่ำเพื่อหลีกเลี่ยงการปฏิเสธการวนซ้ำในกรณีที่กำหนดขึ้น
2. (เร่งความเร็วเพิ่มเติม: ลองคู่เดียว $n$ ครั้งที่ไหน $n$คือความยาวหรืออินพุตของคุณ หากสองผลลัพธ์ใด ๆ กลับต่างกันจะได้การเปลี่ยนแปลงที่ได้ใน (1)
3. จัดเรียงอาร์เรย์ของคุณโดยใช้การจัดเรียงผสาน

ให้ลำดับความสัมพันธ์ที่กำหนดไว้ล่วงหน้าเป็นตัวเปรียบเทียบอัลกอริทึมนี้จะเรียงลำดับอาร์เรย์ในเวลา $\mathcal{O}(n \log n)$ ตั้งแต่การสับเปลี่ยน Fisher-Yates ทำงาน $\mathcal{O}(n)$ ใช้สูงสุด $\mathcal{O}(\log n)$"บิตสุ่ม" ที่ไม่ใช่สุ่ม (เช่นการเรียกไปยังเครื่องมือเปรียบเทียบของคุณ) ในแต่ละขั้นตอนและการเรียงแบบผสานมีความซับซ้อนเชิงซีมโทติคเหมือนกัน ผลลัพธ์ของ (1) ไร้ประโยชน์โดยสิ้นเชิงในกรณีนี้ แต่เนื่องจากตามมาด้วยการเรียงลำดับจริงจึงไม่เป็นอันตราย

เมื่อมีการพลิกเหรียญจริงเมื่อเปรียบเทียบ (1) อนุญาตอาร์เรย์ที่มีความน่าจะเป็นเท่ากันสำหรับการเปลี่ยนแปลงแต่ละครั้งและถ้าคุณต้องทำจริง ๆ (3) (คุณออกไป (2) หรือ (2) ล้มเหลวในการพิจารณาแบบสุ่ม) นี่ไม่ใช่ เป็นอันตรายเนื่องจากการกระจายของผลลัพธ์ขึ้นอยู่กับลำดับของอินพุตที่กระจายอย่างสม่ำเสมอในทุกวิธีเรียงสับเปลี่ยนเนื่องจาก (1) ดังนั้นผลลัพธ์ของอัลกอริธึมทั้งหมดจึงกระจายอย่างสม่ำเสมอ จำนวนครั้งที่ต้องสุ่มตัวอย่างการปฏิเสธการตอบรับซ้ำแต่ละครั้งมีการกระจายเชิงเรขาคณิต (ปฏิเสธด้วยความน่าจะเป็น$< \frac{1}{2}$) และดังนั้นจึงมีค่าที่คาดหวัง $< 2$. การทำซ้ำแต่ละครั้งจะใช้อย่างมากที่สุด$\log n$บิตดังนั้นการวิเคราะห์รันไทม์เกือบเช่นเดียวกับในกรณีที่กำหนด แต่เราเท่านั้นที่จะได้รับการรันไทม์คาดของ$\mathcal{O}(n \log n)$ด้วยความเป็นไปได้ของการกำจัด (สิ้นสุดเพียงเกือบแน่นอน )

---

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

---

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

---

อัลกอริทึมต่อไปนี้ไม่มีเฟสที่แตกต่างกันในการสุ่มและเรียงลำดับ แต่ช้าลงแบบไม่แสดงอาการ มันเป็นหลักจัดเรียงแทรกกับการค้นหาแบบไบนารี ฉันจะใช้$a=(a_1,\dots,a_n)$ เพื่อแสดงถึงอินพุตและ $b_k=(b_{k,1},\dots,b_{k,k})$ เพื่อแสดงผลลัพธ์หลังจาก $k$- รอบที่:

1. ชุด $b_{1,1} = a_1$
2. ถ้า $a_2 < a_1$ แล้วก็ $b_2 = (a_2,a_1)$ และ $(c,d):= (2,1)$ อื่น $b_2 = (a_1,a_2)$ และ $(c,d):= (1,2)$. ไม่ว่าในกรณีใด$a_d < a_c$ จะเป็น $0$ (เช่นเท็จ) สำหรับเครื่องมือเปรียบเทียบแบบไม่สุ่ม
3. ที่จะได้รับ $b_{k}$ สำหรับ $k \geq 3$ ได้รับ $b_{k-1}$ เป็นครั้งแรก
4. ปล่อย $l=\lceil log_2 k \rceil$ และ $k' = 2^l$เช่น $k'$ เป็นพลังที่น้อยที่สุด $2$ ไม่เล็กกว่า $k$.
5. ปล่อย $i_0 = 0$. สำหรับทุกคน$j \in \{1,\dots,l\}$ ปล่อย $$i_j = \begin{cases} i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} > k-1 \wedge a_d < a_c\\ i_{j-1} & i_{j-1} + 2^{l-j} > k-1 \wedge \neg (a_d < a_c)\\ i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} \leq k-1 \wedge b_{k-1,i_{j-1} + 2^{l-j}} < a_k \\ i_{j-1} & i_{j-1} + 2^{l-j} \leq k-1 \wedge \neg(b_{k-1,i_{j-1} + 2^{l-j}} < a_k) \\ \end{cases}$$
6. ถ้า $i_l > k$ ทำซ้ำ (5. ) อื่น ๆ $b_k=(b_{k-1,1},\dots,b_{k-1,i_l -1},a_k,b_{k-1,i_l},\dots,b_{k-1,k-1})$
7. เอาท์พุต $b_n$

กรณีสุ่ม: 5 + ถ้าข้อ 6 เป็นตัวอย่างการยอมรับ - ปฏิเสธเป็นหลัก อัลกอริทึมที่เหลือคือการสลับแบบไร้เดียงสา: สับเปลี่ยนเป็นอันดับแรก$k-1$ องค์ประกอบและเพิ่ม $k$องค์ประกอบ -th ของแต่ละตำแหน่งที่มีความน่าจะเป็นที่เท่ากัน หากเราใช้การเรียงลำดับการแทรกแบบปกติเราจะได้การแจกแจงแบบทวินามแทน

โปรดทราบว่าอัลกอริทึมนี้ไม่มีประสิทธิภาพในทั้งสองโหมดเมื่อเปรียบเทียบกับการสับเปลี่ยนแบบ Fisher-Yates และการเรียงแบบผสานขณะที่การแทรกองค์ประกอบไปยังตำแหน่งที่กำหนดเองจะมีราคาแพงหากใช้อาร์เรย์และการค้นหาแบบไบนารี่ต้องการเวลาเชิงเส้น แต่บางทีการดัดแปลง heap sort หรือ tree sort ในทำนองเดียวกันอาจทำให้อัลกอริทึมเร็วขึ้น

ไม่เป็นไปไม่ได้นอกจาก $n \leq 2$. ความน่าจะเป็นที่การเปลี่ยนแปลงเกิดขึ้นโดยอัลกอริทึมของคุณโดยใช้เครื่องมือเปรียบเทียบแบบสุ่มคือ dyadic เช่นรูปแบบ$A/2^B$ในขณะที่น่าจะเป็น $1/n!$. เมื่อไหร่$n > 2$ไม่มีวิธีเขียน $1/n!$ ในรูปแบบ $A/2^B$.