มีกองมั่นคงหรือไม่

มีโครงสร้างข้อมูลคิวลำดับความสำคัญที่รองรับการดำเนินการต่อไปนี้หรือไม่?

• แทรก (x, p) : เพิ่มระเบียนใหม่ x พร้อมลำดับความสำคัญ p
• StableExtractMin () : การกลับมาและลบระเบียนที่มีลำดับความสำคัญต่ำสุดที่จะหมดความสัมพันธ์ตามคำสั่งแทรก

ดังนั้นหลังจาก Insert (a, 1), Insert (b, 2), Insert (c, 1), Insert (d, 2), ลำดับของ StableExtractMin จะคืนค่า a, จากนั้น c จากนั้น b จากนั้น d

เห็นได้ชัดว่าใครสามารถใช้โครงสร้างข้อมูลคิวลำดับความสำคัญใด ๆโดยการจัดเก็บคู่เป็นลำดับความสำคัญที่เกิดขึ้นจริง แต่ฉันสนใจในโครงสร้างข้อมูลที่ไม่ได้เก็บเวลาการแทรก (หรือลำดับการแทรก) อย่างชัดเจน .$(p, time)$

เท่ากัน (?): มี heapsort รุ่นเสถียรที่ไม่ต้องการพื้นที่พิเศษไหม?$\Omega(n)$

วิธีการ Bently-Saxe ให้ลำดับความสำคัญที่ค่อนข้างคงที่ตามธรรมชาติ

เก็บข้อมูลของคุณในลำดับของอาร์เรย์เรียง0 , ... , k ฉันมีขนาด2ฉัน แต่ละอาร์เรย์ยังรักษาเคาน์เตอร์คฉัน รายการอาร์เรย์A i [ c i ] , … , A i [ 2 i - 1 ]มีข้อมูล$A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

สำหรับแต่ละองค์ประกอบทั้งหมดในฉันถูกเพิ่มมากขึ้นเมื่อเร็ว ๆ นี้กว่าผู้ที่อยู่ในฉัน+ 1และในแต่ละฉันองค์ประกอบจะได้รับคำสั่งโดยค่ามีความสัมพันธ์ที่ถูกทำลายโดยการวางองค์ประกอบเก่าไปข้างหน้าขององค์ประกอบใหม่ โปรดทราบว่านี่หมายความว่าเราสามารถรวมA iและA i + 1และรักษาลำดับนี้ไว้ (ในกรณีของความสัมพันธ์ระหว่างการรวมเอาองค์ประกอบจากA i + 1 )$i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

ในการแทรกค่าให้หาi ที่เล็กที่สุดที่A iมี 0 องค์ประกอบรวมA 0 , … , A i - 1และxเก็บไว้ในA iและตั้งค่าc 0 , … , c iอย่างเหมาะสม$x$$i$$A_i$$A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

เพื่อดึงนาทีที่หาดัชนีที่ใหญ่ที่สุดดังกล่าวว่าองค์ประกอบแรกในฉัน [ C ฉัน ]เป็นต่ำสุดมากกว่าทุกฉันและเพิ่มคฉัน$i$$A_i[c_i]$$i$$c_i$

โดยอาร์กิวเมนต์มาตรฐานสิ่งนี้จะให้เวลาที่ตัดจำหน่ายต่อการดำเนินการและมีเสถียรภาพเนื่องจากการสั่งซื้อที่อธิบายไว้ข้างต้น$O(\log n)$

ลำดับของแทรกและสกัดการใช้งานนี้nรายการอาร์เรย์ (ไม่ให้อาร์เรย์ที่ว่างเปล่า) บวกO ( บันทึกn )คำพูดของข้อมูลการทำบัญชี ไม่ตอบคำถามของ Mihai แต่ก็แสดงให้เห็นว่าข้อ จำกัด ที่มั่นคงไม่จำเป็นต้องใช้พื้นที่มาก โดยเฉพาะอย่างยิ่งแสดงให้เห็นว่าไม่มีΩ ( n )ที่ต่ำกว่าที่ถูกผูกไว้ในพื้นที่พิเศษที่จำเป็น$n$$n$$O(\log n)$$\Omega(n)$

Update: Rolf Fagerberg ชี้ให้เห็นว่าถ้าเราสามารถเก็บค่า Null (ไม่ใช่ข้อมูล) ได้โครงสร้างข้อมูลทั้งหมดนี้สามารถบรรจุลงในอาร์เรย์ที่มีขนาดโดยที่nคือจำนวนของการแทรก$n$$n$

ก่อนอื่นให้สังเกตว่าเราสามารถแพ็คลงในอาร์เรย์ในลำดับนั้น (ด้วยA kก่อนตามด้วยA k - 1หากไม่ใช่ที่ว่างเปล่าและอื่น ๆ ) โครงสร้างของสิ่งนี้ถูกเข้ารหัสอย่างสมบูรณ์โดยการแทนเลขฐานสองของnจำนวนขององค์ประกอบที่ใส่เข้าไป หากการแทนค่าฐานสองของnมี 1 ที่ตำแหน่งiดังนั้นA iจะใช้ตำแหน่งอาเรย์2 iมิฉะนั้นจะไม่มีตำแหน่งอาเรย์$A_k,\ldots,A_0$$A_k$$A_{k-1}$$n$$n$$i$$A_i$$2^i$

เมื่อแทรก, และความยาวของอาเรย์ของเราเพิ่มขึ้น 1 และเราสามารถรวมA 0 , … , A iบวกองค์ประกอบใหม่โดยใช้อัลกอริธึมการรวมที่มีเสถียรภาพในสถานที่$n$$A_0,\ldots,A_i$

ตอนนี้ที่เราใช้ค่า null อยู่ในการกำจัดเคาน์เตอร์ฉัน ในฉันเราจะจัดเก็บค่าแรกตามด้วยคฉันค่า null ตามด้วยส่วนที่เหลืออีก2 ฉัน - คฉัน - 1ค่า ในระหว่างการให้สารสกัดจากนาทีเรายังคงสามารถหาค่าสารสกัดในO ( บันทึกn )เวลาโดยการตรวจสอบ0 [ 0 ] , ... , k [ 0 ] เมื่อเราพบค่านี้ในA i [ $c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$เราตั้งฉัน [ 0 ]โมฆะแล้วทำค้นหาแบบทวิภาคในฉันจะหาคนแรกที่ค่าที่ไม่ใช่ nullฉัน [ C ฉัน ]และสลับฉัน [ 0 ]และฉัน [ C ฉัน ]$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

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

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

ในการค้นหาขั้นต่ำให้ดูที่รากของต้นไม้

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

ในการแทรกองค์ประกอบเพิ่มเข้าไปในตำแหน่งว่างถัดไปในแถวด้านล่างของต้นไม้และปรับปรุงเส้นทางไปยังราก หรือถ้าแถวด้านล่างเต็มให้เพิ่มขนาดของต้นไม้เป็นสองเท่า (อีกครั้งด้วยอาร์กิวเมนต์ค่าตัดจำหน่ายโปรดทราบว่าส่วนนี้ไม่แตกต่างจากความต้องการที่จะสร้างใหม่เมื่อฮีปไบนารีแบบมาตรฐานมีจำนวนมากกว่าแถวลำดับ)

มันไม่ใช่คำตอบของคำถามที่เข้มงวดกว่าของ Mihai เนื่องจากมันใช้หน่วยความจำมากเป็นสองเท่าของโครงสร้างข้อมูลโดยนัยที่แท้จริงแม้ว่าเราจะไม่สนใจค่าใช้จ่ายในการจัดการกับการลบอย่างขี้เกียจ

การตีความปัญหาของคุณถูกต้องหรือไม่:

คุณต้องเก็บคีย์ N ในอาร์เรย์ของ A [1..N] โดยไม่มีข้อมูลเสริมเช่นที่คุณสามารถรองรับ: * ปุ่มแทรก * ลบนาทีซึ่งจะเลือกองค์ประกอบแทรกที่เก่าที่สุดหากมีหลายขั้นตอนน้อยที่สุด

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

น่าสนใจ

คำตอบสั้น ๆ : คุณทำไม่ได้

ตอบอีกเล็กน้อย:

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

และสำหรับแต่ละส่วนของข้อมูลที่คุณเก็บคุณจะสามารถที่จะ "ซ่อน" ข้อมูลบางอย่างในที่อยู่ (เช่นd d R ( X ) < d d R ( Y )หมายถึง Y เก่ากว่า X) แต่ในข้อมูลที่ "ซ่อนอยู่" คุณจะซ่อนข้อมูล "อายุ" หรือข้อมูล "เรียกคืนอย่างรวดเร็ว" ไม่ใช่ทั้งคู่$addr(X) < addr(Y)$

คำตอบที่ยาวมากด้วยการหลอกคณิตศาสตร์ที่ไม่แน่นอน:

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

ลองคิดเกี่ยวกับปริมาณข้อมูลที่เกี่ยวข้องกับเครื่อง X-bit (เช่น 32 หรือ 64 บิต) ด้วยเรกคอร์ด (ค่าและลำดับความสำคัญ) คำกว้าง$P$

คุณมีชุดของระเบียนที่เป็นไปได้ที่สั่งบางส่วน: และ( a , 1 ) = ( a , 1 )แต่คุณไม่สามารถเปรียบเทียบ( a , 1 )และ( b , 1 )$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

อย่างไรก็ตามคุณต้องการเปรียบเทียบสองค่าที่ไม่สามารถเทียบเคียงได้กับชุดของระเบียนของคุณ ดังนั้นคุณได้ที่นี่ชุดของค่าอื่น: ผู้ที่ได้รับการแทรกและคุณต้องการที่จะเพิ่มความมันด้วยการสั่งซื้อบางส่วน: IFF Xถูกแทรกก่อนY$X < Y$$X$$Y$

ในกรณีที่เลวร้ายที่สุดหน่วยความจำของคุณจะถูกบันทึกไว้ในแบบฟอร์ม (ด้วย?แตกต่างกันสำหรับแต่ละคน) ดังนั้นคุณจะต้องพึ่งพาเวลาแทรกทั้งหมดเพื่อตัดสินใจว่าจะไปที่ใด ออกก่อน$(?,1)$$?$

• เวลาแทรก (สัมพันธ์กับบันทึกอื่น ๆ ที่ยังอยู่ในโครงสร้าง) ต้องใช้บิตข้อมูล (ด้วย P-byte payload และ2 Xไบต์ที่เข้าถึงได้ของหน่วยความจำ)$X - log_2(P)$$2^X$
• เพย์โหลด (ค่าบันทึกและลำดับความสำคัญของคุณ) ต้องใช้คำพูดของเครื่อง$P$

นั่นหมายความว่าคุณจะต้องอย่างใดเก็บบิตพิเศษของข้อมูลสำหรับแต่ละระเบียนคุณเก็บ และนั่นคือO ( n )สำหรับnบันทึก$X - log_2(P)$$O(n)$$n$

ทีนี้แต่ละหน่วยความจำ "เซลล์" ของข้อมูลมีหน่วยเป็นเท่าใด?

• บิต Wของข้อมูล ( Wเป็นความกว้างของเครื่องคำ)$W$$W$
• บิต$X$

ทีนี้สมมติว่า (payload มีความกว้างเครื่องอย่างน้อยหนึ่งคำ (โดยปกติจะเป็นหนึ่ง octet)) ซึ่งหมายความว่าX - l o g 2 ( P ) < Xเพื่อให้เราสามารถใส่ข้อมูลคำสั่งแทรกในที่อยู่ของเซลล์ นั่นคือสิ่งที่เกิดขึ้นในสแต็ก: เซลล์ที่มีที่อยู่ต่ำสุดป้อนสแต็กก่อน (และจะออกล่าสุด)$P \geq 1$$X - log_2(P) < X$

ดังนั้นในการจัดเก็บข้อมูลทั้งหมดของเราเรามีความเป็นไปได้สองประการ:

• เก็บคำสั่งแทรกในที่อยู่และเพย์โหลดในหน่วยความจำ
• เก็บทั้งในหน่วยความจำและปล่อยให้ที่อยู่ฟรีสำหรับการใช้งานอื่น

เห็นได้ชัดว่าเพื่อหลีกเลี่ยงของเสียเราจะใช้วิธีแก้ปัญหาแรก

ตอนนี้สำหรับการดำเนินงาน ฉันคิดว่าคุณต้องการที่จะมี:

• กับ O ( L o กรัมn )ความซับซ้อนเวลา$Insert(task, priority)$$O(log n)$
• กับ O ( L o กรัมn )ความซับซ้อนเวลา$StableExtractMin()$$O(log n)$

ดู Let 's ที่ :$StableExtractMin()$

อัลกอริทึมทั่วไปที่แท้จริงจริงๆจะเป็นดังนี้:

1. พบระเบียนที่มีลำดับความสำคัญขั้นต่ำและขั้นต่ำ "เวลาแทรก" ใน )$O(log n)$
2. ลบออกจากโครงสร้างใน )$O(log n)$
3. ส่งคืนได้

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

กลับไปที่อัลกอริทึมทั่วไปเราจะเห็นว่าการค้นหาระเบียนในเวลาเราต้องการวิธีที่รวดเร็วในการเลือกหนึ่งที่เหมาะสมระหว่างผู้สมัครที่2 ( X - l o g 2 ( P ) ) (แย่ที่สุด) กรณีหน่วยความจำเต็ม)$O(log n)$$2^(X - log_2(P))$

ซึ่งหมายความว่าเราจำเป็นต้องเก็บบิตของข้อมูลเพื่อดึงองค์ประกอบนั้น (แต่ละบิตแบ่งพื้นที่ผู้สมัครออกเป็นสองส่วนดังนั้นเราจึงมีO ( l o g n ) bisections หมายถึงO ( l o g n )ความซับซ้อนของเวลา)$X - log_2(P)$$O(log n)$$O(log n)$

บิตของข้อมูลเหล่านี้อาจถูกเก็บไว้เป็นที่อยู่ขององค์ประกอบ (ในฮีป, min คือที่ที่อยู่คงที่) หรือด้วยพอยน์เตอร์เช่น (ในแผนภูมิการค้นหาแบบไบนารี่ (ที่มีพอยน์เตอร์) คุณต้องติดตามโดยเฉลี่ยเพื่อไปยังนาที)$O(log n)$

$O(log n)$$X - log_2(P)$

$O(log n)$

$X - log_2(P)$$O(log n)$

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

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

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

ฉันไม่คิดว่าเป็นไปได้

กรณีคอนกรีต:

       x
    x    x
  x  x  1  x
1  x  

ขั้นต่ำของกองกับทั้งหมด x> 1

ในที่สุดการเลือกฮีปซิงก์ก็เป็นทางเลือกเช่นกัน

       x
    1    1
  x  x  x  x
x  x  

ตอนนี้ที่ 1 เพื่อเผยแพร่ไปยังรูต?