คำถามติดแท็ก algorithm-analysis

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

2
มีการใช้การวิเคราะห์ที่ราบรื่นนอกสถาบันการศึกษาหรือไม่
การวิเคราะห์ที่ราบรื่นนั้นหาทางเข้าไปสู่การวิเคราะห์กระแสหลักของอัลกอริทึมหรือไม่? เป็นเรื่องปกติหรือไม่ที่ผู้ออกแบบอัลกอริทึมจะใช้การวิเคราะห์ที่ราบรื่นกับอัลกอริทึมของพวกเขา

2
ทำไมการเพิ่มความน่าจะเป็นของบันทึกจึงเร็วกว่าการคูณความน่าจะเป็น
ในการวางกรอบคำถามในวิทยาการคอมพิวเตอร์บ่อยครั้งที่เราต้องการคำนวณผลคูณของความน่าจะเป็น: P(A,B,C) = P(A) * P(B) * P(C) วิธีที่ง่ายที่สุดคือการคูณตัวเลขเหล่านี้และนั่นคือสิ่งที่ฉันจะทำ อย่างไรก็ตามเจ้านายของฉันกล่าวว่าการเพิ่มบันทึกของความน่าจะเป็นดีกว่า: log(P(A,B,C)) = log(P(A)) + log(P(B)) + log(P(C)) นี่จะให้ความน่าจะเป็นของบันทึก แต่เราสามารถได้ความน่าจะเป็นหลังจากนั้นถ้าจำเป็น: P(A,B,C) = e^log(P(A,B,C)) การเพิ่มบันทึกถือว่าดีกว่าด้วยเหตุผลสองประการ: มันป้องกัน "underflow" โดยผลิตภัณฑ์ของความน่าจะเป็นมีขนาดเล็กจนมันถูกปัดเศษเป็นศูนย์ สิ่งนี้มักเป็นความเสี่ยงเนื่องจากความน่าจะเป็นมีขนาดเล็กมาก มันเร็วกว่าเพราะสถาปัตยกรรมคอมพิวเตอร์จำนวนมากสามารถทำการเพิ่มได้เร็วกว่าการคูณ คำถามของฉันเกี่ยวกับประเด็นที่สอง นี่คือวิธีที่ฉันได้เห็นมันอธิบาย แต่ไม่คำนึงถึงค่าใช้จ่ายเพิ่มเติมในการรับบันทึก! เราควรจะเปรียบเทียบ "ต้นทุนของล็อก + ค่าใช้จ่ายของการเพิ่ม" กับ "ต้นทุนของการคูณ" มันยังมีขนาดเล็กลงหลังจากที่คำนึงถึงเรื่องนี้หรือไม่? นอกจากนี้หน้า Wikipedia ( ความน่าจะเป็นบันทึก ) นั้นสร้างความสับสนในแง่นี้โดยระบุว่า "การแปลงเป็นไฟล์บันทึกมีราคาแพง แต่เกิดขึ้นเพียงครั้งเดียวเท่านั้น" ฉันไม่เข้าใจสิ่งนี้เพราะฉันคิดว่าคุณจะต้องใช้บันทึกของทุกคำศัพท์อย่างอิสระก่อนที่จะเพิ่ม ฉันพลาดอะไรไป ในที่สุดเหตุผลที่ว่า "คอมพิวเตอร์ทำการเพิ่มเร็วกว่าการคูณ" …

3
ฟังก์ชั่นที่มีการเติบโตช้ากว่า Ackermann ผกผันปรากฏในขอบเขตรันไทม์หรือไม่?
อัลกอริธึมที่ซับซ้อนบางอย่าง ( ยูเนี่ยน - พบ ) มีฟังก์ชัน Ackermann ผกผันเกือบคงที่ที่ปรากฏในความซับซ้อนของเวลาแบบอะซิมโทติคและเป็นเวลาที่เลวร้ายที่สุดกรณีที่เหมาะสมที่สุดถ้าเทอม Ackermann ผกผันเกือบคงที่ มีตัวอย่างของอัลกอริธึมที่ทราบพร้อมเวลาทำงานที่เกี่ยวข้องกับฟังก์ชันที่เติบโตช้ากว่า Invermann หรือไม่ (เช่นผู้บุกรุกฟังก์ชันที่ไม่เทียบเท่า Ackermann ภายใต้พหุนามหรือเอกซ์โปเนนเชียล ฯลฯ ) ที่ให้เวลากรณีเลวร้ายที่สุด ซับซ้อนในการแก้ปัญหาพื้นฐานหรือไม่

7
อะไรคือคุณสมบัติของอัลกอริทึมความซับซ้อนของเวลา
บางครั้งมันง่ายที่จะระบุความซับซ้อนของเวลาของอัลกอริทึมที่ฉันตรวจสอบอย่างรอบคอบ อัลกอริทึมที่มีสองวงซ้อนกันของจะเห็นได้ชัด 2 อัลกอริทึมที่สำรวจทั้งหมดรวมกันเป็นไปได้ของกลุ่มของสองค่าจะเห็นได้ชัด NNNNN2N2N^2NNN2N2N2^N อย่างไรก็ตามฉันไม่ทราบวิธี "ระบุ" อัลกอริทึมที่มีความซับซ้อนตัวอย่างการนำไปใช้การผสานแบบเรียกซ้ำเป็นแบบหนึ่ง อะไรคือคุณสมบัติทั่วไปของการรวมหรืออัลกอริทึมอื่น ๆที่จะให้เบาะแสถ้าฉันวิเคราะห์มัน?Θ(NlogN)Θ(Nlog⁡N)\Theta(N \log N)Θ(NlogN)Θ(Nlog⁡N)\Theta(N \log N) ฉันแน่ใจว่ามีมากกว่าหนึ่งวิธีที่อัลกอริทึมอาจมีความซับซ้อนดังนั้นคำตอบใด ๆ และทั้งหมดก็ได้รับการชื่นชม BTW ฉันกำลังมองหาคุณสมบัติและเคล็ดลับทั่วไปไม่ใช่หลักฐานที่เข้มงวดΘ(NlogN)Θ(Nlog⁡N)\Theta(N \log N)

5
การเรียกซ้ำ Collatz ทำงานนานเท่าใด
ฉันมีรหัส Python ดังต่อไปนี้ def collatz(n): if n <= 1: return True elif (n%2==0): return collatz(n/2) else: return collatz(3*n+1) เวลาทำงานของอัลกอริทึมนี้คืออะไร ลอง: ถ้าหมายถึงเวลาทำงานของฟังก์ชั่น จากนั้นฉันคิดว่าฉันมี T(n)T(n)T(n)collatz(n)⎧⎩⎨T(n)=1 for n≤1T(n)=T(n/2) for n evenT(n)=T(3n+1) for n odd{T(n)=1 for n≤1T(n)=T(n/2) for n evenT(n)=T(3n+1) for n odd\begin{cases} T(n)=1 \text{ for } n\le 1\\ T(n)=T(n/2) \text{ for } n\text{ …

1
การทำงานของอัลกอริทึมของ Ukkonen ขึ้นอยู่กับขนาดตัวอักษรอย่างไร
ฉันกังวลกับคำถามเกี่ยวกับเวลาที่ใช้ในการทำงานแบบไม่แสดงอาการของอัลกอริทึมของ Ukkonenซึ่งอาจเป็นอัลกอริทึมที่ได้รับความนิยมมากที่สุดสำหรับการสร้างต้นไม้ต่อท้ายในเวลาเชิงเส้น (?) นี่คือการอ้างอิงจากหนังสือ "อัลกอริทึมในสตริงต้นไม้และลำดับ" โดย Dan Gusfield (ส่วน 6.5.1): "... อัลกอริธึมAho-Corasick, Weiner, Ukkonenและ McCreight นั้นต้องการพื้นที่หรือเวลาต้องถูกแทนที่ด้วยค่าต่ำสุดของและ "Θ(m|Σ|)Θ(m|Σ|)\Theta(m|\Sigma|)O(m)O(m)O(m)O(mlogm)O(mlog⁡m)O(m \log m)O(mlog|Σ|)O(mlog⁡|Σ|)O(m \log|\Sigma|) [คือความยาวสตริงและคือขนาดของตัวอักษร]mmmΣΣ\Sigma ฉันไม่เข้าใจว่าทำไมถึงเป็นจริง พื้นที่:ดีในกรณีที่เราเป็นตัวแทนของสาขาออกจากโหนดใช้อาร์เรย์ขนาดแล้วแน่นอนเราจบลงด้วยการใช้พื้นที่ อย่างไรก็ตามเท่าที่ฉันเห็นมันเป็นไปได้ที่จะจัดเก็บกิ่งไม้โดยใช้ตารางแฮช (เช่นพจนานุกรมใน Python) จากนั้นเราจะมีเฉพาะตัวชี้เก็บไว้ในตารางแฮชทั้งหมด (เนื่องจากมีขอบในต้นไม้) ในขณะที่ยังคงสามารถเข้าถึงโหนดลูกในเวลาเร็วที่สุด เช่นเดียวกับเมื่อใช้อาร์เรย์Θ(|Σ|)Θ(|Σ|)\Theta(|\Sigma|)Θ(m|Σ|)Θ(m|Σ|)\Theta(m|\Sigma|)Θ(m)Θ(m)\Theta(m)Θ(m)Θ(m)\Theta(m)O(1)O(1)O(1) เวลา : ดังกล่าวข้างต้นโดยใช้ตารางแฮชช่วยให้เราสามารถเข้าถึงสาขาขาออกของโหนดใด ๆ ในเวลา ตั้งแต่ขั้นตอนวิธี Ukkonen ต้องใช้การดำเนินงาน (รวมถึงการเข้าถึงโหนดเด็ก) เวลาการทำงานโดยรวมแล้วจะเป็นยัง(เมตร)O(1)O(1)O(1)O(m)O(m)O(m)O(m)O(m)O(m) ฉันจะขอบคุณคุณเป็นอย่างมากสำหรับคำแนะนำใด ๆ ว่าทำไมฉันถึงเข้าใจผิดในข้อสรุปของฉันและทำไม Gusfield ถึงถูกต้องเกี่ยวกับการพึ่งพาอัลกอริทึมของ Ukkonen ในตัวอักษร

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

4
เหตุใด Quickized Quicksort จึงมีค่าใช้จ่ายรันไทม์ที่แย่ที่สุดในกรณี O (n log n)
การจัดเรียงแบบด่วนแบบสุ่มเป็นส่วนขยายของการเรียงแบบด่วนซึ่งองค์ประกอบของเดือยจะถูกเลือกแบบสุ่ม สิ่งที่สามารถซับซ้อนเวลากรณีที่เลวร้ายที่สุดของอัลกอริทึมนี้ ตามที่ผมมันควรจะเป็นO(n2)O(n2)O(n^2)เป็นกรณีที่เลวร้ายที่สุดที่เกิดขึ้นเมื่อหมุนสุ่มเลือกถูกเลือกในเรียงหรือเรียงย้อนกลับการสั่งซื้อ แต่ในบางตำรา [1] [2]ความซับซ้อนของเวลากรณีที่เลวร้ายที่สุดถูกเขียนเป็นO(nlogn)O(nlog⁡n)O(n\log{n}) ถูกต้องอะไร

2
มีอะไรที่ยากกว่า: การสับสำรับที่เรียงแล้วหรือการเรียงสับแบบสับ
คุณมีอาร์เรย์ขององค์ประกอบที่แตกต่างกันคุณสามารถเข้าถึงตัวเปรียบเทียบ (ฟังก์ชันกล่องดำที่รับสององค์ประกอบaและbและคืนค่าจริง iff a &lt; b ) และแหล่งบิตสุ่มอย่างแท้จริง (ฟังก์ชันกล่องดำไม่มีอาร์กิวเมนต์และคืนบิตสุ่มแบบสุ่มอย่างสม่ำเสมอ) พิจารณางานสองอย่างต่อไปนี้:nnnaaabbba&lt;ba&lt;ba < b อาร์เรย์ถูกเรียงในขณะนี้ ผลิตการเรียงสับเปลี่ยนที่เลือกแบบสุ่ม (หรือโดยประมาณอย่างสม่ำเสมอ) อาร์เรย์ประกอบด้วยการเรียงสับเปลี่ยนที่เลือกอย่างสม่ำเสมอโดยการสุ่มโดยธรรมชาติ สร้างอาร์เรย์ที่เรียงลำดับ คำถามของฉันคือ งานใดที่ต้องใช้พลังงานมากขึ้น ฉันไม่สามารถนิยามคำถามได้อย่างแม่นยำมากขึ้นเพราะฉันไม่รู้เกี่ยวกับการเชื่อมต่อระหว่างทฤษฎีสารสนเทศอุณหพลศาสตร์หรืออะไรก็ตามที่จำเป็นในการตอบคำถามนี้ อย่างไรก็ตามฉันคิดว่าคำถามสามารถสร้างได้อย่างชัดเจน (และหวังว่าจะมีคนช่วยฉันด้วยคำตอบนี้!) ตอนนี้อัลกอริทึมปรีชาของฉันคือพวกมันเท่ากัน ขอให้สังเกตว่าการเรียงลำดับทั้งหมดเป็นการสลับกลับกันและในทางกลับกัน การเรียงลำดับต้องใช้รถในขณะที่สับเพราะมันหยิบเปลี่ยนแปลงสุ่มจากn ! ตัวเลือกต้องใช้log n ! ≈ n log nบิตแบบสุ่ม ทั้งการสับและการเรียงต้องใช้n swapslogn!≈nlognlog⁡n!≈nlog⁡n\log n! \approx n \log nn!n!n!logn!≈nlognlog⁡n!≈nlog⁡n\log n! \approx n \log nnnn อย่างไรก็ตามฉันรู้สึกว่าควรมีคำตอบที่ใช้หลักการของ Landauerซึ่งบอกว่าต้องใช้พลังงานในการ "ลบ" เล็กน้อย ฉันคิดว่านี่หมายถึงการเรียงลำดับอาร์เรย์นั้นยากกว่าเพราะต้องใช้ …

2
ข้อได้เปรียบของ Randomized Quicksort คืออะไร
ในหนังสือของพวกเขาแบบสุ่มอัลกอริทึม , Motwani และ Raghavan เปิดการแนะนำที่มีคำอธิบายของฟังก์ชั่น RandQS ของพวกเขา - quicksort สุ่ม - ที่หมุนที่ใช้สำหรับการแบ่งชุดออกเป็นสองส่วนคือการสุ่มเลือก ฉันได้รับสมองของฉัน (ค่อนข้างอ่อนแอภายใต้การยอมรับ) ในช่วงเวลานี้ แต่ฉันไม่สามารถเห็นได้ว่าข้อดีของอัลกอริทึมนี้มีมากกว่าการเลือกพูดองค์ประกอบกลาง (ในดัชนีไม่ใช่ขนาด) ในแต่ละครั้ง ฉันคิดว่าสิ่งที่ฉันไม่เห็นคือ: ถ้าชุดเริ่มต้นอยู่ในลำดับสุ่มความแตกต่างระหว่างการเลือกองค์ประกอบที่ตำแหน่งสุ่มในชุดและเลือกองค์ประกอบที่ตำแหน่งคงที่คืออะไร ใครบางคนสามารถสอนฉันในแง่ที่ค่อนข้างง่าย?

4
การเกิดซ้ำและฟังก์ชันสร้างในอัลกอริทึม
Combinatorics มีบทบาทสำคัญในวิทยาการคอมพิวเตอร์ เราใช้วิธี combinatorial ในการวิเคราะห์และการออกแบบอัลกอริทึมบ่อยครั้ง ตัวอย่างเช่นวิธีหนึ่งสำหรับการค้นหาชุดkkk -vertex ในกราฟอาจตรวจสอบชุดย่อย(nk)(nk)\binom{n}{k}เป็นไปได้ทั้งหมด ในขณะที่ฟังก์ชั่นทวินามเติบโตขึ้นแบบทวีคูณถ้าkkkเป็นค่าคงที่ที่แน่นอนเราจะสิ้นสุดด้วยอัลกอริธึมเวลาพหุนามโดยการวิเคราะห์เชิงเส้นกำกับ บ่อยครั้งที่ปัญหาในชีวิตจริงต้องการกลไกการผสมผสานที่ซับซ้อนมากขึ้นซึ่งเราอาจนิยามในแง่ของการเกิดซ้ำ ตัวอย่างที่มีชื่อเสียงอย่างหนึ่งคือลำดับฟีโบนักชี (ไร้เดียงสา) ที่นิยามเป็น: f(n)=⎧⎩⎨10f(n−1)+f(n−2)if n=1if n=0otherwisef(n)={1if n=10if n=0f(n−1)+f(n−2)otherwisef(n) = \begin{cases} 1 & \text{if } n = 1 \\ 0 & \text{if } n = 0 \\ f(n-1) + f(n-2) & \text{otherwise} \end{cases} ขณะนี้การคำนวณมูลค่าของคำศัพท์ที่nnnเพิ่มขึ้นแบบทวีคูณโดยใช้การเกิดซ้ำนี้ แต่ด้วยการเขียนโปรแกรมแบบไดนามิกเราอาจคำนวณในเวลาเชิงเส้น ทีนี้ไม่ใช่การเกิดซ้ำทั้งหมดให้ตัวเองกับ DP (ฟังก์ชั่นแฟกทอเรียล) แต่มันเป็นคุณสมบัติที่สามารถเอาเปรียบได้เมื่อกำหนดบางอย่างว่าเป็นการเกิดซ้ำมากกว่าฟังก์ชั่นการสร้าง ฟังก์ชั่นการสร้างเป็นวิธีที่สง่างามในการทำให้เป็นรูปเป็นร่างสำหรับโครงสร้างที่กำหนด บางทีที่มีชื่อเสียงที่สุดคือฟังก์ชันการสร้างทวินามที่กำหนดเป็น: …

4
ทำไมเราไม่ใช้การจัดเรียงอย่างรวดเร็วในรายการที่เชื่อมโยง?
อัลกอริทึมการเรียงลำดับด่วนสามารถแบ่งออกเป็นขั้นตอนต่อไปนี้ ระบุเดือย แบ่งพาร์ติชันรายการที่เชื่อมโยงตาม pivot แบ่งรายการที่เชื่อมโยงแบบวนซ้ำเป็น 2 ส่วน ตอนนี้ถ้าผมมักจะเลือกองค์ประกอบสุดท้ายเป็นเดือยแล้วระบุองค์ประกอบหมุน (ขั้นตอนที่ 1) ใช้เวลาเวลาO(n)O(n)\mathcal O(n) หลังจากระบุองค์ประกอบ pivot เราสามารถจัดเก็บข้อมูลและเปรียบเทียบกับองค์ประกอบอื่น ๆ ทั้งหมดเพื่อระบุจุดพาร์ติชันที่ถูกต้อง (ขั้นตอนที่ 2) เปรียบเทียบแต่ละคนจะใช้เวลาเวลาที่เราเก็บข้อมูลเดือยและแต่ละแลกเปลี่ยนใช้เวลาO ( 1 )เวลา ดังนั้นโดยรวมจะใช้เวลาO ( n )สำหรับองค์ประกอบnO(1)O(1)\mathcal O(1)O(1)O(1)\mathcal O(1)O(n)O(n)\mathcal O(n)nnn ดังนั้นความสัมพันธ์ที่เกิดซ้ำคือ: ซึ่งเป็น O ( n log n )ซึ่งเหมือนกับในการเรียงแบบผสานกับรายการที่เชื่อมโยงT(n)=2T(n/2)+nT(n)=2T(n/2)+nT(n) = 2T(n/2) + nO(nlogn)O(nlog⁡n)\mathcal O(n \log n) เหตุใดจึงต้องจัดเรียงผสานมากกว่าการจัดเรียงด่วนสำหรับรายการที่เชื่อมโยง

1
กำลังแรงเดรัจฉาน Delaunay triangulation อัลกอริธึมที่ซับซ้อน
ในหนังสือ"เรขาคณิตการคำนวณ: อัลกอริธึมและการประยุกต์ใช้"โดย Mark de Berg และคณะมีอัลกอริทึมแรงเดรัจฉานที่ง่ายมากสำหรับการคำนวณสามเหลี่ยมเดอลูเนย์ อัลกอริทึมใช้ความคิดของขอบผิดกฎหมาย - ขอบที่อาจไม่ปรากฏในสมการ Delaunay ที่ถูกต้องและต้องถูกแทนที่ด้วยขอบอื่น ๆ ในแต่ละขั้นตอนอัลกอริทึมจะค้นหาขอบที่ผิดกฎหมายเหล่านี้และทำการกระจัดที่ต้องการ (เรียกว่าการพลิกขอบ ) จนกระทั่งไม่มีขอบที่ผิดกฎหมาย อัลกอริทึมการบีบอัดทางกฎหมาย ( TTT ) อินพุต บางสมTTTของจุดที่ตั้งPเอาท์พุต สมการทางกฎหมายของPPPP PPP ในขณะที่ มีขอบที่ผิดกฎหมายp i p j doTTTpipjpipjp_ip_j \quadให้และP ฉันพีเจพีลิตรเป็นรูปสามเหลี่ยมสองรูปที่อยู่ติดกับหน้าฉันพีเจpipjpkpipjpkp_i p_j p_kpipjplpipjplp_i p_j p_lpipjpipjp_ip_j \quadลบจากTและเพิ่มp k p lแทน ผลตอบแทน Tpipjpipjp_ip_jTTTpkplpkplp_kp_l TTT ฉันได้ยินมาว่าอัลกอริทึมนี้ทำงานในเวลาในกรณีที่แย่ที่สุด; อย่างไรก็ตามมันไม่ชัดเจนสำหรับฉันว่าข้อความนี้ถูกต้องหรือไม่ ถ้าใช่จะพิสูจน์ได้อย่างไรว่าขอบเขตบนนี้O(n2)O(n2)O(n^2)

4
Quicksort อธิบายให้เด็ก ๆ ฟัง
ปีที่แล้วผมได้อ่านที่ยอดเยี่ยมบนกระดาษ“กลศาสตร์ควอนตัสำหรับอนุบาล” มันไม่ใช่กระดาษง่าย ๆ ตอนนี้ฉันสงสัยว่าจะอธิบายอย่างรวดเร็วด้วยคำพูดที่ง่ายที่สุดเท่าที่จะเป็นไปได้ ฉันจะพิสูจน์ (หรืออย่างน้อยก็ด้วยมือ) ว่าความซับซ้อนโดยเฉลี่ยคือและกรณีที่ดีที่สุดและเลวร้ายที่สุดคืออะไรกับชั้นอนุบาล หรืออย่างน้อยในโรงเรียนประถม?O ( n บันทึกn )O(nเข้าสู่ระบบ⁡n)O(n \log n)

2
ฮีป - ให้อัลกอริทึมเวลา
อาจเป็นไปได้ว่าคำถามนี้ถูกถามมาก่อน มันมาจาก CLRS (2nd Ed) ปัญหา 6.5-8 - ให้อัลกอริทึมเวลาเพื่อรวมรายการที่เรียงลำดับkไว้ในรายการที่เรียงลำดับหนึ่งรายการโดยที่nคือจำนวนองค์ประกอบทั้งหมดในรายการอินพุตทั้งหมด (คำแนะนำ: ใช้ min-heap สำหรับการรวมk -way)O(nlgk)O(nlg⁡k)O(n \lg k)kkknnnkkk เนื่องจากมีรายการที่เรียงลำดับและค่าnทั้งหมดให้เราสมมติว่าแต่ละรายการมีnkkknnnหมายเลข kยิ่งไปกว่านั้นแต่ละรายการจะเรียงตามลำดับจากน้อยไปหามากและผลลัพธ์จะถูกเก็บไว้ในลำดับจากน้อยไปหามากnknk\frac{n}{k} โค้ดหลอกของฉันดูเหมือนว่านี้ - list[k] ; k sorted lists heap[k] ; an auxiliary array to hold the min-heap result[n] ; array to store the sorted list for i := 1 to k ; O(k) …

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.