หนึ่งกองสองคิว

พื้นหลัง

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

วันนี้ฉันจำปัญหาได้ ฉันยังอยากรู้ดังนั้นที่นี่มัน ...

คำถาม

เป็นไปได้หรือไม่ที่จะนำสแต็กมาใช้โดยใช้สองคิวเพื่อให้การดำเนินการทั้งPUSH และPOPทำงานในเวลาที่ตัดจำหน่าย O (1) ? ถ้าใช่คุณจะบอกฉันได้อย่างไร

หมายเหตุ: สถานการณ์นั้นค่อนข้างง่ายหากเราต้องการใช้คิวที่มีสองกอง (พร้อมการดำเนินการที่เกี่ยวข้องENQUEUE & DEQUEUE ) โปรดสังเกตความแตกต่าง

PS: ปัญหาข้างต้นไม่ใช่การบ้าน การบ้านไม่ต้องการขอบเขตที่ต่ำกว่า เพียงการดำเนินการและการวิเคราะห์เวลาทำงาน

ฉันไม่มีคำตอบจริง แต่นี่คือหลักฐานบางอย่างที่ว่าปัญหาเปิดอยู่:

• มันไม่ได้กล่าวถึงใน Ming Li, Luc Longpréและ Paul MB Vitányi, "พลังแห่งคิว", โครงสร้าง 1986 ซึ่งพิจารณาอีกหลายเหตุการณ์ที่เกี่ยวข้องอย่างใกล้ชิด

• มันไม่ได้กล่าวถึงใน Martin Hühne "Theor ด้วยพลังของหลาย ๆ คิว" Theor คอมพ์ วิทย์ 2536 กระดาษที่ตามมา

• มันไม่ได้กล่าวถึงใน Holger Petersen "กองซ้อนกับ Deques", COCOON 2001

• เบอร์ตันโรเซ็นเบิร์ก "การรู้จำ nondeterministic อย่างรวดเร็วของภาษาที่ไม่มีบริบทโดยใช้สองคิว" แจ้ง พร เลทท์ ปี 1998 ให้อัลกอริทึมสองคิว O (n log n) สำหรับการรับรู้ CFL ใด ๆ โดยใช้สองคิว แต่ออโตเมติกแบบกดลงแบบ nondeterministic สามารถรับรู้ CFL ได้ในเวลาเชิงเส้น ดังนั้นหากมีการจำลองสแต็กที่มีสองคิวเร็วกว่า O (บันทึก n) ต่อการดำเนินการ Rosenberg และผู้ตัดสินของเขาควรรู้เกี่ยวกับมัน

คำตอบดังต่อไปนี้คือ 'โกง' ในขณะที่มันไม่ได้ใช้พื้นที่ใด ๆ ระหว่างการดำเนินการการดำเนินงานที่ตัวเองสามารถใช้มากกว่าพื้นที่ ดูที่อื่นในหัวข้อนี้สำหรับคำตอบที่ไม่มีปัญหานี้$O(1)$

ในขณะที่ฉันไม่มีคำตอบสำหรับคำถามที่แน่นอนของคุณ แต่ฉันพบอัลกอริทึมที่ทำงานในเวลาแทนO(n) ฉันเชื่อว่านี่มันแน่น แต่ฉันไม่มีหลักฐาน หากมีสิ่งใดอัลกอริทึมแสดงให้เห็นว่าการพยายามพิสูจน์ขอบเขตล่างของO(n)นั้นไร้ประโยชน์ดังนั้นจึงอาจช่วยตอบคำถามของคุณได้$O(\sqrt{n})$$O(n)$$O(n)$

ฉันนำเสนออัลกอริทึมสองอย่างสิ่งแรกคืออัลกอริธึมแบบง่ายโดยใช้เวลาสำหรับป๊อปและที่สองด้วยO ( $O(n)$เวลาที่ใช้สำหรับป๊อป ฉันอธิบายคนแรกส่วนใหญ่เป็นเพราะความเรียบง่ายเพื่อให้คนที่สองง่ายต่อการเข้าใจ$O(\sqrt{n})$

หากต้องการให้รายละเอียดเพิ่มเติม: ครั้งแรกที่ไม่ใช้พื้นที่เพิ่มเติมมีกรณีที่เลวร้ายที่สุด (และตัดจำหน่าย) Push และO ( n )กรณีที่เลวร้ายที่สุด (และตัดจำหน่าย) ป๊อป แต่พฤติกรรมกรณีที่เลวร้ายที่สุดไม่ได้เรียกเสมอ เนื่องจากไม่ได้ใช้พื้นที่เพิ่มเติมนอกเหนือจากสองคิวจึง 'ดีกว่า' เล็กน้อยกว่าโซลูชันที่ Ross Snider นำเสนอ$O(1)$$O(n)$

ที่สองใช้เขตข้อมูลจำนวนเต็มเดียว (ดังนั้นพื้นที่พิเศษ ), มีO ( 1 )กรณีที่เลวร้ายที่สุด (และตัดจำหน่าย) ผลักดันและO ( $O(1)$$O(1)$ป๊อปตัดจำหน่าย เวลาทำงานจึงดีกว่าวิธีการ 'เรียบง่าย' อย่างมาก แต่ก็ใช้พื้นที่เพิ่มเติมบางส่วน$O(\sqrt{n})$

อัลกอริทึมแรก

เรามีสองคิว: คิวและคิวs อีคo n d ฉฉันr s Tจะผลักดันคิว 'ของเราในขณะที่อีคo n dจะเป็นคิวที่มีอยู่แล้วในการสั่งซื้อสแต็ค'$first$$second$$first$$second$

• ผลักดันที่จะทำโดยเพียงแค่ enqueueing พารามิเตอร์บน T$first$
• Popping ทำได้ดังนี้ หากเป็นที่ว่างเปล่าเราก็ dequeue s อีคo n dและกลับผล มิฉะนั้นเราจะย้อนกลับฉฉันr s Tผนวกทั้งหมดของs อีคo n dจะฉฉันr s Tและสลับฉฉันr s Tและs อีคo n d จากนั้นเราจะ dequeue s อีค$first$$second$$first$$second$$first$$first$$second$และส่งคืนผลลัพธ์ของ dequeue$second$

รหัส C # สำหรับอัลกอริทึมแรก

สิ่งนี้ควรอ่านได้แม้ว่าคุณจะไม่เคยเห็น C # มาก่อนก็ตาม หากคุณไม่ทราบว่าชื่อสามัญคืออะไรให้แทนที่ 'สตริง' ด้วย 'สตริง' ทั้งหมดในใจของคุณเพื่อเป็นชุดของสตริง

public class Stack<T> {
    private Queue<T> first = new Queue<T>();
    private Queue<T> second = new Queue<T>();
    public void Push(T value) {
        first.Enqueue(value);
    }
    public T Pop() {
        if (first.Count == 0) {
            if (second.Count > 0)
                return second.Dequeue();
            else
                throw new InvalidOperationException("Empty stack.");
        } else {
            int nrOfItemsInFirst = first.Count;
            T[] reverser = new T[nrOfItemsInFirst];

            // Reverse first
            for (int i = 0; i < nrOfItemsInFirst; i++)
                reverser[i] = first.Dequeue();    
            for (int i = nrOfItemsInFirst - 1; i >= 0; i--)
                first.Enqueue(reverser[i]);

            // Append second to first
            while (second.Count > 0)
                first.Enqueue(second.Dequeue());

            // Swap first and second
            Queue<T> temp = first; first = second; second = temp;

            return second.Dequeue();
        }
    }
}

การวิเคราะห์

เห็นได้ชัดว่าผลักดันงานในเวลา ป๊อปอาจจะสัมผัสกับทุกอย่างภายในฉฉันr s Tและs อีคo n dเป็นจำนวนเงินที่คงที่ของเวลาดังนั้นเราจึงมีO ( n )ในกรณีที่เลวร้ายที่สุด ขั้นตอนวิธีการแสดงพฤติกรรมนี้ (ตัวอย่างเช่น) หากผลักดันnองค์ประกอบบนสแต็คแล้วซ้ำแล้วซ้ำอีกจะดำเนินการผลักดันไหม้และการดำเนินงานที่ป๊อปเดียวในการสืบทอด$O(1)$$first$$second$$O(n)$$n$

อัลกอริทึมที่สอง

เรามีสองคิว: คิวและคิวs อีคo n d ฉฉันr s Tจะผลักดันคิว 'ของเราในขณะที่อีคo n dจะเป็นคิวที่มีอยู่แล้วในการสั่งซื้อสแต็ค'$first$$second$$first$$second$

นี้เป็นรุ่นที่ดัดแปลงของขั้นตอนวิธีแรกที่เราทำไม่ได้ทันที 'สับ' เนื้อหาของเข้าไปs อีคo n d แต่ถ้าฉฉันr s ทีมีขนาดเล็กจำนวนเพียงพอขององค์ประกอบเมื่อเทียบกับs อีคo n d (คือรากที่สองของจำนวนขององค์ประกอบในs อีคo n d ) เราเพียงจัดระเบียบฉฉันr s Tในลำดับสแต็กและไม่รวมเข้าด้วย$first$$second$$first$$second$$second$$first$ d$second$

• ผลักดันจะทำยังโดยเพียงแค่ enqueueing พารามิเตอร์บน T$first$
• Popping ทำได้ดังนี้ หากเป็นที่ว่างเปล่าเราก็ dequeue s อีคo n dและกลับผล มิฉะนั้นเราจัดระเบียบเนื้อหาของฉฉันr s Tเพื่อให้พวกเขาอยู่ในลำดับที่สแต็ค ถ้า| f i r s t | < $first$$second$$first$เราก็ dequeueฉฉันrsTและส่งกลับผล มิฉะนั้นเราผนวกsอีคondบนฉฉันrsTสลับฉฉันrsTและsอีคond, dequeuesอีคondและกลับผล$|first| < \sqrt{|second|}$$first$$second$$first$$first$$second$$second$

รหัส C # สำหรับอัลกอริทึมแรก

สิ่งนี้ควรอ่านได้แม้ว่าคุณจะไม่เคยเห็น C # มาก่อนก็ตาม หากคุณไม่ทราบว่าชื่อสามัญคืออะไรให้แทนที่ 'สตริง' ด้วย 'สตริง' ทั้งหมดในใจของคุณเพื่อเป็นชุดของสตริง

public class Stack<T> {
    private Queue<T> first = new Queue<T>();
    private Queue<T> second = new Queue<T>();
    int unsortedPart = 0;
    public void Push(T value) {
        unsortedPart++;
        first.Enqueue(value);
    }
    public T Pop() {
        if (first.Count == 0) {
            if (second.Count > 0)
                return second.Dequeue();
            else
                throw new InvalidOperationException("Empty stack.");
        } else {
            int nrOfItemsInFirst = first.Count;
            T[] reverser = new T[nrOfItemsInFirst];

            for (int i = nrOfItemsInFirst - unsortedPart - 1; i >= 0; i--)
                reverser[i] = first.Dequeue();

            for (int i = nrOfItemsInFirst - unsortedPart; i < nrOfItemsInFirst; i++)
                reverser[i] = first.Dequeue();

            for (int i = nrOfItemsInFirst - 1; i >= 0; i--)
                first.Enqueue(reverser[i]);

            unsortedPart = 0;
            if (first.Count * first.Count < second.Count)
                return first.Dequeue();
            else {
                while (second.Count > 0)
                    first.Enqueue(second.Dequeue());

                Queue<T> temp = first; first = second; second = temp;

                return second.Dequeue();
            }
        }
    }
}

การวิเคราะห์

เห็นได้ชัดว่าผลักดันงานในเวลา$O(1)$

ป๊อปทำงานในเวลาตัดจำหน่าย มีสองกรณี: ถ้า| first| <$O(\sqrt{n})$แล้วเราสับเปลี่ยนฉฉันrsTเป็นใบสั่งสแต็คในO(|ฉฉันrsT|)=O($|first| < \sqrt{|second|}$$first$เวลา ถ้า| first| ≥$O(|first|) = O(\sqrt{n})$แล้วเราจะต้องมีอย่างน้อย$|first| \geq \sqrt{|second|}$เรียกร้องให้กด ดังนั้นเราสามารถตีคดีนี้ได้ทุก$\sqrt{n}$โทรไปยัง Push and Pop เวลาทำงานจริงสำหรับกรณีนี้คือO(n)ดังนั้นเวลาที่ตัดจำหน่ายคือO($\sqrt{n}$$O(n)$ )$O(\frac{n}{\sqrt{n}}) = O(\sqrt{n})$

หมายเหตุสุดท้าย

มันเป็นไปได้ที่จะกำจัดตัวแปรพิเศษด้วยค่าใช้จ่ายในการสร้าง Pop an การดำเนินงานโดยมีป๊อปจัดระเบียบฉฉันrsTทวงถามแทนที่จะต้องกดทุกทำทุกงาน$O(\sqrt{n})$$first$

ตามความคิดเห็นบางคำตอบก่อนหน้านี้ของฉันมันชัดเจนสำหรับฉันว่าฉันโกงมากหรือน้อย: ฉันใช้พื้นที่พิเศษ ( พื้นที่พิเศษในอัลกอริธึมที่สอง) ระหว่างการดำเนินการตามวิธี Pop ของฉัน$O(\sqrt{n})$

อัลกอริทึมต่อไปนี้ไม่ใช้ช่องว่างเพิ่มเติมระหว่างวิธีการและมีช่องว่างพิเศษระหว่างการดำเนินการ Push และ Pop ดันมีO ( $O(1)$เวลาในการตัดจำหน่ายและป๊อปมีO(1)กรณีที่เลวร้ายที่สุด (และตัดจำหน่าย) เวลาในการทำงาน$O(\sqrt{n})$$O(1)$

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

อัลกอริทึม

เรามีสองคิว: คิวและคิวs อีคo n d ฉฉันr s Tจะ 'แคช' ของเราในขณะที่อีคo n dจะเป็นที่เก็บ 'หลักของเรา คิวทั้งสองจะอยู่ใน 'คำสั่งซื้อสแต็ก' เสมอ ฉฉันr s Tจะมีองค์ประกอบที่ด้านบนของสแต็คและที่s อีคo n dจะมีองค์ประกอบที่ด้านล่างของสแต็ค ขนาดของf ฉัน$first$$second$$first$$second$$first$$second$จะเป็นที่มากที่สุดรากที่สองของ s อีคo n d$first$$second$

• ผลักดันที่จะทำโดย 'แทรก' พารามิเตอร์ในช่วงเริ่มต้นของคิวดังต่อไปนี้เรา enqueue พารามิเตอร์ที่จะแล้ว dequeue และ re-enqueue องค์ประกอบอื่น ๆ ทั้งหมดในฉฉันr s T วิธีนี้พารามิเตอร์จะสิ้นสุดลงในช่วงเริ่มต้นของฉฉันr s T$first$$first$$first$
• หากกลายเป็นขนาดใหญ่กว่ารากที่สองของs อีคo n dเรา enqueue องค์ประกอบทั้งหมดของs อีคo n dบนฉฉันr s ทีหนึ่งโดยหนึ่งแล้วสลับฉฉันr s Tและs อีคo n d วิธีนี้องค์ประกอบของฉฉันr s T (บนสุดของสแต็ค) จบลงที่หัวของs $first$$second$$second$$first$$first$$second$$first$ d$second$
• ป๊อปจะกระทำโดย dequeueing และกลับมาผลหากฉฉันr s Tไม่ว่างเปล่าและอื่น ๆ โดย dequeueing s อีคo n dและกลับมาผล$first$$first$$second$

รหัส C # สำหรับอัลกอริทึมแรก

รหัสนี้ควรอ่านได้แม้ว่าคุณจะไม่เคยเห็น C # มาก่อนก็ตาม หากคุณไม่ทราบว่าชื่อสามัญคืออะไรให้แทนที่ 'สตริง' ด้วย 'สตริง' ทั้งหมดในใจของคุณเพื่อเป็นชุดของสตริง

public class Stack<T> {
    private Queue<T> first = new Queue<T>();
    private Queue<T> second = new Queue<T>();
    public void Push(T value) {
        // I'll explain what's happening in these comments. Assume we pushed
        // integers onto the stack in increasing order: ie, we pushed 1 first,
        // then 2, then 3 and so on.

        // Suppose our queues look like this:
        // first: in 5 6 out
        // second: in 1 2 3 4 out
        // Note they are both in stack order and first contains the top of
        // the stack.

        // Suppose value == 7:
        first.Enqueue(value);
        // first: in 7 5 6 out
        // second: in 1 2 3 4 out

        // We restore the stack order in first:
        for (int i = 0; i < first.Count - 1; i++)
            first.Enqueue(first.Dequeue());
        // first.Enqueue(first.Dequeue()); is executed twice for this example, the 
        // following happens:
        // first: in 6 7 5 out
        // second: in 1 2 3 4 out
        // first: in 5 6 7 out
        // second: in 1 2 3 4 out

        // first exeeded its capacity, so we merge first and second.
        if (first.Count * first.Count > second.Count) {
            while (second.Count > 0)
                first.Enqueue(second.Dequeue());
            // first: in 4 5 6 7 out
            // second: in 1 2 3 out
            // first: in 3 4 5 6 7 out
            // second: in 1 2 out
            // first: in 2 3 4 5 6 7 out
            // second: in 1 out
            // first: in 1 2 3 4 5 6 7 out
            // second: in out

            Queue<T> temp = first; first = second; second = temp;
            // first: in out
            // second: in 1 2 3 4 5 6 7 out
        }
    }
    public T Pop() {
        if (first.Count == 0) {
            if (second.Count > 0)
                return second.Dequeue();
            else
                throw new InvalidOperationException("Empty stack.");
        } else
            return first.Dequeue();
    }
}

การวิเคราะห์

เห็นได้ชัดว่าป๊อปทำงานในเวลาในกรณีที่เลวร้ายที่สุด$O(1)$

พุชทำงานในเวลาตัดจำหน่าย มีสองกรณี: ถ้า| first| <$O(\sqrt{n})$จากนั้น Push ใช้เวลาO($|first| < \sqrt{|second|}$เวลา ถ้า| first| ≥$O(\sqrt{n})$แล้วกดใช้เวลาO(n)เวลา แต่หลังจากการดำเนินการนี้ฉฉันrsTจะว่างเปล่า มันจะใช้O($|first| \geq \sqrt{|second|}$$O(n)$$first$เวลาก่อนที่เราจะได้รับกรณีนี้อีกครั้งดังนั้นเวลาที่ตัดจำหน่ายคือO($O(\sqrt{n})$เวลา$O(\frac{n}{\sqrt{n}}) = O(\sqrt{n})$

ฉันอ้างว่าเรามีค่าตัดจำหน่ายต่อการดำเนินงาน อัลกอริทึมของอเล็กซ์ให้ขอบเขตบน เพื่อพิสูจน์ขอบเขตล่างฉันให้ลำดับกรณีที่แย่ที่สุดของ PUSH และ POP$\Theta(\sqrt{N})$

ลำดับเคสที่แย่ที่สุดประกอบด้วยการดำเนินการ PUSH ตามด้วย$N$การดำเนินงาน N PUSH และ$\sqrt{N}$การทำงานของ POP แบบ Nตามด้วย √อีกครั้ง$\sqrt{N}$การดำเนินงาน N PUSH และ$\sqrt{N}$ POP เป็นต้นนั่นคือ:$\sqrt{N}$

$PUSH^N (PUSH^{\sqrt{N}} POP^{\sqrt{N}})^{\sqrt{N}}$

พิจารณาสถานการณ์หลังจากการดำเนินการ PUSH เริ่มต้น ไม่ว่าอัลกอริทึมจะทำงานอย่างไรอย่างน้อยหนึ่งในคิวต้องมีอย่างน้อยN / 2รายการ$N$$N/2$

ตอนนี้ให้พิจารณางานที่ต้องจัดการกับ (ชุดแรก) PUSH และ POP การดำเนินงาน ชั้นเชิงอัลกอริทึมใด ๆ จะต้องตกอยู่ในหนึ่งในสองกรณี:$\sqrt{N}$

ในกรณีแรกอัลกอริทึมจะใช้ทั้งสองคิว คิวที่ใหญ่กว่านี้มีอย่างน้อยรายการในนั้นดังนั้นเราต้องเสียค่าใช้จ่ายอย่างน้อยการดำเนินการคิวN / 2เพื่อที่จะดึงข้อมูลได้ในที่สุดแม้แต่องค์ประกอบเดียวที่เรา ENQUEUE และต่อมาจำเป็นต้อง DEQUEUE จากคิวที่ใหญ่กว่านี้$N/2$$N/2$

ในกรณีที่สองอัลกอริทึมไม่ได้ใช้ทั้งสองคิว สิ่งนี้ช่วยลดปัญหาในการจำลองสแต็กด้วยคิวเดียว แม้ว่าคิวนี้จะว่างเปล่าในตอนแรกเราไม่สามารถทำได้ดีกว่าการใช้คิวเป็นรายการแบบวงกลมที่มีการเข้าถึงตามลำดับและปรากฏตรงไปตรงมาว่าเราต้องใช้อย่างน้อยการดำเนินการคิว N /2โดยเฉลี่ยสำหรับแต่ละ2$\sqrt{N}/2$การดำเนินการสแต็ก$2\sqrt{N}$

ในทั้งสองกรณีเราต้องใช้เวลาอย่างน้อย (การทำงานคิว) เพื่อจัดการ2 $N/2$การดำเนินการสแต็ก เพราะเราสามารถทำซ้ำขั้นตอนนี้$2\sqrt{N}$คูณเราต้องการN$\sqrt{N}$ในการประมวลผลการดำเนินการทั้งหมด3Nสแต็กทำให้ขอบเขตต่ำกว่าΩ($N\sqrt{N}/2$$3N$เวลาตัดจำหน่ายต่อการดำเนินงาน$\Omega(\sqrt{N})$

$O(\lg n)$$push$$pop$$pop$$O(\lg n)$$pop$ มีการร้องขอและเอาต์พุตคิวว่างคุณดำเนินการลำดับการสับแบบสมบูรณ์เพื่อย้อนกลับอินพุตคิวและเก็บไว้ในเอาต์พุตคิว

$O(1)$

เท่าที่ฉันรู้นี่เป็นความคิดใหม่ ...

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

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

• $A$$B$
• ทุกครั้งที่มีการดำเนินการพุชให้พลิกบิตและใส่องค์ประกอบลงในคิวที่บิตถูกกำหนดในขณะนี้ ดึงทุกอย่างออกจากคิวอื่น ๆ แล้วกดลงบนคิวปัจจุบัน
• การดำเนินการแบบป๊อปจะปิดด้านหน้าคิวปัจจุบันและไม่ได้สัมผัสบิตสถานะภายนอก

แน่นอนว่าเราสามารถเพิ่มสถานะภายนอกอีกเล็กน้อยซึ่งบอกเราว่าการดำเนินการครั้งสุดท้ายเป็นการผลักหรือป๊อป เราสามารถชะลอการย้ายทุกอย่างจากคิวหนึ่งไปอีกคิวหนึ่งจนกระทั่งเราได้รับการดำเนินการพุชสองครั้งติดต่อกัน สิ่งนี้ยังทำให้การดำเนินการของป๊อปซับซ้อนขึ้นเล็กน้อย สิ่งนี้ทำให้เรามี O (1) ค่าตัดจำหน่ายที่ซับซ้อนสำหรับการดำเนินงานป๊อป น่าเสียดายที่การกดยังคงเป็นเส้นตรง

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

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

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

นี่เป็นอีกทางเลือกหนึ่ง:

อัลกอริทึมนี้ต้องใช้สองคิวและสองพอยน์เตอร์เราจะเรียกพวกเขาว่า Q1, Q2, หลักและรองตามลำดับ เมื่อเริ่มต้น Q1 และ Q2 จะว่างเปล่าคะแนนหลักไปที่ Q1 และคะแนนรองถึง Q2

การดำเนินการผลักดันเป็นเรื่องเล็กน้อยประกอบด้วยเพียง:

*primary.enqueue(value);

การดำเนินการกับ POP มีส่วนเกี่ยวข้องมากกว่าเล็กน้อย มันต้องการการสปูลทั้งหมด แต่รายการสุดท้ายของคิวหลักไปที่คิวรองสลับพอยน์เตอร์และส่งคืนรายการสุดท้ายที่เหลือจากคิวเดิม:

while(*primary.size() > 1)
{
    *secondary.enqueue(*primary.dequeue());
}

swap(primary, secondary);
return(*secondary.dequeue());

ไม่มีการตรวจสอบขอบเขตและไม่มี O (1)

ขณะที่ฉันพิมพ์สิ่งนี้ฉันเห็นว่าสิ่งนี้สามารถทำได้โดยใช้คิวเดียวโดยใช้ for for loop แทนที่จะเป็นลูปชั่วขณะเหมือน Alex ที่ทำไปแล้ว ทั้งสองวิธีการดำเนินการ PUSH คือ O (1) และการดำเนินการ POP กลายเป็น O (n)

นี่คือโซลูชันอื่นที่ใช้สองคิวและตัวชี้หนึ่งเรียกว่า Q1, Q2 และ que_p ตามลำดับ:

เมื่อเริ่มต้น Q1 และ Q2 จะว่างเปล่าและ queue_p ชี้ไปที่ Q1

อีกครั้งการดำเนินการ PUSH เป็นเรื่องเล็กน้อย แต่ไม่ต้องการขั้นตอนเพิ่มเติมอีกหนึ่งขั้นตอนในการชี้ Que_p ที่คิวอื่น:

*queue_p.enqueue(value);
queue_p = (queue_p == &Q1) ? &Q2 : &Q1;

การดำเนินการ POP คล้ายกับก่อนหน้านี้ แต่ตอนนี้มีรายการ n / 2 ที่ต้องหมุนผ่านคิว:

queue_p = (queue_p == &Q1) ? &Q2 : &Q1;
for(i=0, i<(*queue_p.size()-1, i++)
{
    *queue_p.enqueue(*queue_p.dequeue());
}
return(*queue_p.dequeue());

การดำเนินการ PUSH ยังคงเป็น O (1) แต่ตอนนี้การดำเนินการ POP คือ O (n / 2)

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

$k$$Θ(n^{1/k})$

$k$
$n$
$O(1)$

$i$$Θ(n^{i/k})$$Θ(n^{i/k})$$O(1)$$i+1$$O(n^{1/k})$$i-1$$Θ(n^{1/k})$

$m$$m$$Ω(mn^{1/k})$$o(n^{1/k})$$Ω(n^{1/k})$$o(n^{2/k})$$k$$o(n)$

$Θ(\log n)$

สแต็กอาจถูกนำมาใช้โดยใช้สองคิวโดยใช้คิวที่สองเป็น ab uffer เมื่อไอเท็มถูกส่งไปยังสแต็กจะถูกเพิ่มเข้ากับท้ายคิว แต่ละครั้งที่ไอเท็มถูกดึงองค์ประกอบ n - 1 ของคิวแรกจะต้องย้ายไปที่สองในขณะที่ไอเท็มที่เหลือจะถูกส่งคืน QueueStack ระดับสาธารณะใช้ ts IStack {IQueue ส่วนตัว q1 = คิวใหม่ (); IQueue ส่วนตัว q2 = คิวใหม่ (); โมฆะสาธารณะแบบพุช (E e) {q1.enqueue (e) // O (1)} ป๊อปอีสาธารณะ (E e) {ในขณะที่ (1 <q1.size ()) // O (n) {q2.enqueue ( q1.dequeue ()); } sw apQueues (); ส่งคืน q2.dequeue (); } p ระว่างโมฆะ swapQueues () {IQueue Q = q2; q2 = q1; q1 = Q; }}