ใช้กองซ้อนโดยใช้สองคิว

คำถามที่คล้ายกันก็ถามว่าก่อนหน้านี้มีแต่คำถามที่นี่เป็นสิ่งที่ตรงกันข้ามของมันใช้สองคิวเป็นกอง คำถาม...

ได้รับสองคิวกับการดำเนินงานมาตรฐาน ( enqueue, dequeue, isempty, size) ใช้กองกับการดำเนินงานมาตรฐาน ( pop, push, isempty, size)

ควรมีโซลูชันสองรุ่น

• เวอร์ชันA : สแต็กควรมีประสิทธิภาพเมื่อกดไอเท็ม และ
• เวอร์ชันB : สแต็กควรมีประสิทธิภาพเมื่อเปิดไอเท็ม

ฉันสนใจอัลกอริทึมมากกว่าการใช้ภาษาเฉพาะใด ๆ อย่างไรก็ตามฉันยินดีต้อนรับวิธีแก้ปัญหาที่แสดงเป็นภาษาที่ฉันคุ้นเคย (ชวา,ค#,หลาม,VB,จาวาสคริปต์,PHP)

เวอร์ชัน A (การพุชที่มีประสิทธิภาพ):

• ผลักดัน:
  • เข้าคิวในคิว 1
• ป๊อป:
  • ในขณะที่ขนาดของคิว 1 มีขนาดใหญ่กว่า 1 ไปป์รายการที่ถูกถอนออกจากคิว 1 ไปยังคิว 2
  • ถอนออกจากรายการและส่งคืนรายการสุดท้ายของ que1 จากนั้นสลับชื่อของ que1 และ que2

เวอร์ชัน B (ป๊อปที่มีประสิทธิภาพ):

• ผลักดัน:
  • เข้าคิวในคิว 2
  • จัดคิวรายการทั้งหมดของ queue1 ใน que2 จากนั้นสลับชื่อของ que1 และ que2
• ป๊อป:
  • deqeue จากคิว 1

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

ขั้นตอนที่ 0:

"Stack"
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

Queue A                Queue B
+---+---+---+---+---+  +---+---+---+---+---+
|   |   |   |   |   |  |   |   |   |   |   |
+---+---+---+---+---+  +---+---+---+---+---+

ขั้นตอนที่ 1:

"Stack"
+---+---+---+---+---+
| 1 |   |   |   |   |
+---+---+---+---+---+

Queue A                Queue B
+---+---+---+---+---+  +---+---+---+---+---+
| 1 |   |   |   |   |  |   |   |   |   |   |
+---+---+---+---+---+  +---+---+---+---+---+

ขั้นตอนที่ 2:

"Stack"
+---+---+---+---+---+
| 2 | 1 |   |   |   |
+---+---+---+---+---+

Queue A                Queue B
+---+---+---+---+---+  +---+---+---+---+---+
|   |   |   |   |   |  | 2 | 1 |   |   |   |
+---+---+---+---+---+  +---+---+---+---+---+

ขั้นตอนที่ 3:

"Stack"
+---+---+---+---+---+
| 3 | 2 | 1 |   |   |
+---+---+---+---+---+

Queue A                Queue B
+---+---+---+---+---+  +---+---+---+---+---+
| 3 | 2 | 1 |   |   |  |   |   |   |   |   |
+---+---+---+---+---+  +---+---+---+---+---+

เราสามารถทำได้ด้วยคิวเดียว:

ผลักดัน:

1. จัดองค์ประกอบใหม่
2. หากnเป็นจำนวนองค์ประกอบในคิวให้ลบและแทรกn-1เวลาองค์ประกอบ

ป๊อป:

1. dequeue

.

push 1


front                     
+----+----+----+----+----+----+
| 1  |    |    |    |    |    |    insert 1
+----+----+----+----+----+----+


push2

front                     
+----+----+----+----+----+----+
| 1  | 2  |    |    |    |    |    insert 2
+----+----+----+----+----+----+

     front                     
+----+----+----+----+----+----+
|    | 2  |  1 |    |    |    |    remove and insert 1
+----+----+----+----+----+----+




 insert 3


      front                     
+----+----+----+----+----+----+
|    | 2  |  1 |  3 |    |    |    insert 3
+----+----+----+----+----+----+

           front                     
+----+----+----+----+----+----+
|    |    |  1 |  3 |  2 |    |    remove and insert 2
+----+----+----+----+----+----+

                front                     
+----+----+----+----+----+----+
|    |    |    |  3 |  2 |  1 |    remove and insert 1
+----+----+----+----+----+----+

การใช้งานตัวอย่าง:

int stack_pop (queue_data *q)
{
  return queue_remove (q);
}

void stack_push (queue_data *q, int val)
{
  int old_count = queue_get_element_count (q), i;

  queue_insert (q, val);
  for (i=0; i<old_count; i++)
  {
    queue_insert (q, queue_remove (q));
  }
}

import java.util.*;

/**
 *
 * @author Mahmood
 */
public class StackImplUsingQueues {

    Queue<Integer> q1 = new LinkedList<Integer>();
    Queue<Integer> q2 = new LinkedList<Integer>();

    public int pop() {
        if (q1.peek() == null) {
            System.out.println("The stack is empty, nothing to return");
            int i = 0;
            return i;
        } else {
            int pop = q1.remove();
            return pop;
        }
    }

    public void push(int data) {

        if (q1.peek() == null) {
            q1.add(data);
        } else {
            for (int i = q1.size(); i > 0; i--) {
                q2.add(q1.remove());
            }
            q1.add(data);
            for (int j = q2.size(); j > 0; j--) {
                q1.add(q2.remove());
            }

        }
    }

    public static void main(String[] args) {
        StackImplUsingQueues s1 = new StackImplUsingQueues();
        //       Stack s1 = new Stack();
        s1.push(1);
        s1.push(2);
        s1.push(3);
        s1.push(4);
        s1.push(5);
        s1.push(6);
        s1.push(7);
        s1.push(8);
        s1.push(9);
        s1.push(10);
        // s1.push(6);
        System.out.println("1st = " + s1.pop());
        System.out.println("2nd = " + s1.pop());
        System.out.println("3rd = " + s1.pop());
        System.out.println("4th = " + s1.pop());
        System.out.println("5th = " + s1.pop());
        System.out.println("6th = " + s1.pop());
        System.out.println("7th = " + s1.pop());
        System.out.println("8th = " + s1.pop());
        System.out.println("9th = " + s1.pop());
        System.out.println("10th= " + s1.pop());
    }
}

เราสามารถใช้หนึ่งคิวเพื่อสร้างสแต็กได้หรือไม่? ฉันสามารถใช้สองคิว แต่การพิจารณาคิวเดียวจะมีประสิทธิภาพมากกว่า นี่คือรหัส:

    public void Push(T val)
    {
        queLower.Enqueue(val);
    }

    public  T Pop()
    {

        if (queLower.Count == 0 )
        {
            Console.Write("Stack is empty!");
            return default(T);

         }
        if (queLower.Count > 0)
        {
            for (int i = 0; i < queLower.Count - 1;i++ )
            {
                queLower.Enqueue(queLower.Dequeue ());
           }
                    }

        return queLower.Dequeue();

    }

queue<int> q1, q2;
int i = 0;

void push(int v) {
  if( q1.empty() && q2.empty() ) {
     q1.push(v);
     i = 0;
  }
  else {
     if( i == 0 ) {
        while( !q1.empty() ) q2.push(q1.pop());
        q1.push(v);
        i = 1-i;
     }
     else {
        while( !q2.empty() ) q1.push(q2.pop());
        q2.push(v);
        i = 1-i;
     }
  }
}

int pop() {
   if( q1.empty() && q2.empty() ) return -1;
   if( i == 1 ) {
      if( !q1.empty() )
           return q1.pop();
      else if( !q2.empty() )
           return q2.pop();
   }
   else {
      if( !q2.empty() )
           return q2.pop();
      else if( !q1.empty() )
           return q1.pop();
   }
}

นี่คือคำตอบของฉัน - ที่ 'ป๊อป' ไม่มีประสิทธิภาพ ดูเหมือนว่าอัลกอริทึมทั้งหมดที่มาพร้อมกับจิตใจจะมีความซับซ้อน N โดยที่ N คือขนาดของรายการ: ไม่ว่าคุณจะเลือกทำงานบน 'ป๊อป' หรือทำงานบน 'ดัน'

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

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

วิธีเดียวที่จะทำให้สิ่งนี้เร็วขึ้นคือการไม่ใช้คิวในตอนแรก

from data_structures import queue

class stack(object):
    def __init__(self):
        q1= queue 
        q2= queue #only contains one item at most. a temp var. (bad?)

    def push(self, item):
        q1.enque(item) #just stick it in the first queue.

    #Pop is inefficient
    def pop(self):
        #'spin' the queues until q1 is ready to pop the right value. 
        for N 0 to self.size-1
            q2.enqueue(q1.dequeue)
            q1.enqueue(q2.dequeue)
        return q1.dequeue()

    @property
    def size(self):
        return q1.size + q2.size

    @property
    def isempty(self):
        if self.size > 0:
           return True
        else
           return False

นี่คือโซลูชันของฉันที่ใช้งานได้กับ O (1) โดยเฉลี่ย มีสองคิวคือและin outดูซอลเบลโลว์ pseudocode:

PUSH(X) = in.enqueue(X)

POP: X =
  if (out.isEmpty and !in.isEmpty)
    DUMP(in, out)
  return out.dequeue

DUMP(A, B) =
  if (!A.isEmpty)
    x = A.dequeue()
    DUMP(A, B)
    B.enqueue(x)

อย่างที่พูดไปแล้วคิวเดียวจะไม่หลอกลวงเหรอ? มันอาจใช้งานได้จริงน้อยลง แต่ค่อนข้างสั่นไหว

push(x):
enqueue(x)
for(queueSize - 1)
   enqueue(dequeue())

pop(x):
dequeue()

นี่คือรหัสหลอกง่ายๆกดคือ O (n) ป๊อป / แอบดูคือ O (1):

Qpush = Qinstance()
Qpop = Qinstance()

def stack.push(item):
    Qpush.add(item)
    while Qpop.peek() != null: //transfer Qpop into Qpush
        Qpush.add(Qpop.remove()) 
    swap = Qpush
    Qpush = Qpop
    Qpop = swap

def stack.pop():
    return Qpop.remove()

def stack.peek():
    return Qpop.peek()

ให้ S1 และ S2 เป็นสองกองที่จะใช้ในการใช้คิว

struct Stack 
{ struct Queue *Q1;
  struct Queue *Q2;
}

เราตรวจสอบให้แน่ใจว่าหนึ่งคิวว่างเปล่าเสมอ

การดำเนินการพุช: ไม่ว่าคิวจะไม่ว่างให้ใส่องค์ประกอบเข้าไป

• ตรวจสอบว่าคิว Q1 ว่างเปล่าหรือไม่ ถ้า Q1 ว่างเปล่าให้ทำการ Enqueue องค์ประกอบในนั้น
• มิฉะนั้น EnQueue องค์ประกอบลงใน Q1

Push (struct Stack *S, int data) { if(isEmptyQueue(S->Q1) EnQueue(S->Q2, data); else EnQueue(S->Q1, data); }

ความซับซ้อนของเวลา: O (1)

การทำงานของป๊อป:ถ่ายโอนองค์ประกอบ n-1 ไปยังคิวอื่นและลบล่าสุดจากคิวเพื่อดำเนินการกับป๊อป

• หากคิว Q1 ไม่ว่างให้ถ่ายโอนองค์ประกอบ n-1 จาก Q1 ถึง Q2 จากนั้น DeQueue องค์ประกอบสุดท้ายของ Q1 และส่งคืน
• หากคิว Q2 ไม่ว่างให้ทำการถ่ายโอนองค์ประกอบ n-1 จาก Q2 ถึงไตรมาส 1 จากนั้น DeQueue องค์ประกอบสุดท้ายของ Q2 และส่งคืน

`

int Pop(struct Stack *S){
int i, size;
if(IsEmptyQueue(S->Q2)) 
{
size=size(S->Q1);
i=0;
while(i<size-1)
{ EnQueue(S->Q2, Dequeue(S->Q1)) ;
  i++;
}
return DeQueue(S->Q1);  
}
else{
size=size(S->Q2);
while(i<size-1)
EnQueue(S->Q1, Dequeue(S->Q2)) ;
i++;
}
return DeQueue(S->Q2);
} }

ความซับซ้อนของเวลา: เวลาในการดำเนินการของป๊อปการดำเนินการคือ O (n) เนื่องจากมีการเรียกป๊อปแต่ละครั้งเรากำลังถ่ายโอนองค์ประกอบทั้งหมดจากคิวหนึ่งไปยังอีกรายการหนึ่ง

Q1 = [10, 15, 20, 25, 30]
Q2 = []

exp:
{   
    dequeue n-1 element from Q1 and enqueue into Q2: Q2 == [10, 15, 20, 25]

    now Q1 dequeue gives "30" that inserted last and working as stack
}

swap Q1 and Q2 then GOTO exp

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
    Queue<Integer> queue1 = new LinkedList<Integer>();
    Queue<Integer> queue2 = new LinkedList<Integer>();

    // Push element x onto stack.
    public void push(int x) {
        if(isEmpty()){
            queue1.offer(x);
        }else{
            if(queue1.size()>0){
                queue2.offer(x);
                int size = queue1.size();
                while(size>0){
                    queue2.offer(queue1.poll());
                    size--;
                }
            }else if(queue2.size()>0){
                queue1.offer(x);
                int size = queue2.size();
                while(size>0){
                    queue1.offer(queue2.poll());
                    size--;
                }
            }
        }
    }

    // Removes the element on top of the stack.
    public void pop() {
        if(queue1.size()>0){
            queue1.poll();
        }else if(queue2.size()>0){
            queue2.poll();
        }
    }

    // Get the top element. You can make it more perfect just example
    public int top() {
       if(queue1.size()>0){
            return queue1.peek();
        }else if(queue2.size()>0){
            return queue2.peek();
        }
        return 0;
    }

    // Return whether the stack is empty.
    public boolean isEmpty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}

นี่คืออีกหนึ่งโซลูชั่น:

สำหรับ PUSH: - เพิ่มองค์ประกอบแรกในคิว 1 - เมื่อเพิ่มองค์ประกอบที่สองและอื่น ๆ ให้เข้าคิวองค์ประกอบในคิว 2 ก่อนจากนั้นจึงคัดลอกองค์ประกอบทั้งหมดจากคิว 1 ถึงคิว 2 - สำหรับ POP เพียงทำการ dequeue องค์ประกอบจากคิวจากคุณแทรกองค์ประกอบสุดท้าย

ดังนั้น,

public void push(int data){
if (queue1.isEmpty()){
    queue1.enqueue(data);
}  else {
queue2.enqueue(data);
while(!queue1.isEmpty())
Queue2.enqueue(queue1.dequeue());
//EXCHANGE THE NAMES OF QUEUE 1 and QUEUE2

}}

public int pop(){
int popItem=queue2.dequeue();
return popItem;
}'

มีปัญหาหนึ่งคือฉันไม่สามารถหาวิธีการเปลี่ยนชื่อคิวได้อย่างไร

#include <bits/stdc++.h>
using namespace std;
queue<int>Q;
stack<int>Stk;
void PRINT(stack<int>ss , queue<int>qq) {
    while( ss.size() ) {
        cout << ss.top() << " " ;
        ss.pop();
    }
    puts("");
    while( qq.size() ) {
        cout << qq.front() << " " ;
        qq.pop();
    }
    puts("\n----------------------------------");
}
void POP() {
    queue<int>Tmp ;
    while( Q.size() > 1 ) {
        Tmp.push( Q.front()  );
        Q.pop();
    }
    cout << Q.front() << " " << Stk.top() << endl;
    Q.pop() , Stk.pop() ;
    Q = Tmp ;
}
void PUSH(int x ) {
    Q.push(x);
    Stk.push(x);
}
int main() {
    while( true ) {
        string typ ;
        cin >> typ ;
        if( typ == "push" ) {
            int x ;
            cin >> x;
            PUSH(x);
        } else POP();
        PRINT(Stk,Q);
    }
}

รหัส Python ใช้คิวเดียวเท่านั้น

 class Queue(object):
    def __init__(self):
        self.items=[]
    def enqueue(self,item):
        self.items.insert(0,item)
    def dequeue(self):
        if(not self.isEmpty()):
            return  self.items.pop()
    def isEmpty(self):
        return  self.items==[]
    def size(self):
        return len(self.items)



class stack(object):
        def __init__(self):
            self.q1= Queue()


        def push(self, item):
            self.q1.enqueue(item) 


        def pop(self):
            c=self.q1.size()
            while(c>1):
                self.q1.enqueue(self.q1.dequeue())
                c-=1
            return self.q1.dequeue()



        def size(self):
            return self.q1.size() 


        def isempty(self):
            if self.size > 0:
               return True
            else:
               return False

นี่คือรหัสการทำงานที่สมบูรณ์ใน c #:

มันได้รับการดำเนินการกับคิวเดี่ยว

ผลักดัน:

1. add new element.
2. Remove elements from Queue (totalsize-1) times and add back to the Queue

ป๊อป:

normal remove





 using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace StackImplimentationUsingQueue
    {
        class Program
        {
            public class Node
            {
                public int data;
                public Node link;
            }
            public class Queue
            {
                public Node rear;
                public Node front;
                public int size = 0;
                public void EnQueue(int data)
                {
                    Node n = new Node();
                    n.data = data;
                    n.link = null;
                    if (rear == null)
                        front = rear = n;
                    else
                    {
                        rear.link = n;
                        rear = n;
                    }
                    size++;
                    Display();
                }
                public Node DeQueue()
                {
                    Node temp = new Node();
                    if (front == null)
                        Console.WriteLine("Empty");
                    else
                    {
                        temp = front;
                        front = front.link;
                        size--;
                    }
                    Display();
                    return temp;
                }
                public void Display()
                {
                    if (size == 0)
                        Console.WriteLine("Empty");
                    else
                    {
                        Console.Clear();
                        Node n = front;
                        while (n != null)
                        {
                            Console.WriteLine(n.data);
                            n = n.link;
                        }
                    }
                }
            }
            public class Stack
            {
                public Queue q;
                public int size = 0;
                public Node top;
                public Stack()
                {
                    q = new Queue();
                }
                public void Push(int data)
                {
                    Node n = new Node();
                    n.data = data;
                    q.EnQueue(data);
                    size++;
                    int counter = size;
                    while (counter > 1)
                    {
                        q.EnQueue(q.DeQueue().data);
                        counter--;
                    }
                }
                public void Pop()
                {
                    q.DeQueue();
                    size--;
                }
            }
            static void Main(string[] args)
            {
                Stack s= new Stack();
                for (int i = 1; i <= 3; i++)
                    s.Push(i);
                for (int i = 1; i < 3; i++)
                    s.Pop();
                Console.ReadKey();
            }
        }
    }

นี่คือโซลูชันที่ง่ายมากซึ่งใช้หนึ่งคิวและให้ฟังก์ชันการทำงานเช่นกองซ้อน

public class CustomStack<T>
{
    Queue<T> que = new Queue<T>();

    public void push(T t) // STACK = LIFO / QUEUE = FIFO
    {

        if( que.Count == 0)
        {
            que.Enqueue(t);
        }
        else
        {
            que.Enqueue(t);
            for (int i = 0; i < que.Count-1; i++)
            {
                var data = que.Dequeue();

                que.Enqueue(data);
            }
        }

    }

    public void pop()
    {

        Console.WriteLine("\nStack Implementation:");
        foreach (var item in que)
        {
            Console.Write("\n" + item.ToString() + "\t");
        }

        var data = que.Dequeue();
        Console.Write("\n Dequeing :" + data);
    }

    public void top()
    {

        Console.Write("\n Top :" + que.Peek());
    }


}

ดังนั้นในคลาสข้างต้นชื่อ "CustomStack" สิ่งที่ฉันกำลังทำอยู่คือตรวจสอบคิวว่างถ้าว่างแล้วใส่หนึ่งและจากนั้นแทรกวอร์ดแล้วลบแทรก โดยตรรกะนี้ก่อนจะมาล่าสุด ตัวอย่าง: ในคิวที่ฉันแทรก 1 และตอนนี้พยายามที่จะแทรก 2 ครั้งที่สองเอา 1 และใส่อีกครั้งเพื่อที่จะกลายเป็นในลำดับที่กลับกัน

ขอบคุณ.

ด้านล่างเป็นโซลูชัน Java ที่ง่ายมากที่สนับสนุนการทำงานแบบกดอย่างมีประสิทธิภาพ

อัลกอริทึม -

1. ประกาศสองคิว q1 และ q2

2. การดำเนินการพุช - กำหนดคิวองค์ประกอบให้คิว q1

3. การทำงานของป๊อป - ตรวจสอบให้แน่ใจว่าคิว q2 ไม่ว่างเปล่า ถ้ามันว่างเปล่าให้ถอนออกจากองค์ประกอบทั้งหมดจาก q1 ยกเว้นองค์ประกอบสุดท้ายและจัดคิวให้เป็น q2 ทีละตัว ถอนออกจากองค์ประกอบสุดท้ายจาก q1 และเก็บไว้เป็นองค์ประกอบที่ถูกตอก สลับคิว q1 และ q2 ส่งคืนองค์ประกอบที่เก็บไว้

4. Peek operation - ตรวจสอบให้แน่ใจว่าคิว q2 ไม่ว่างเปล่า ถ้ามันว่างเปล่าให้ถอนออกจากองค์ประกอบทั้งหมดจาก q1 ยกเว้นองค์ประกอบสุดท้ายและจัดคิวให้เป็น q2 ทีละตัว ถอนออกจากองค์ประกอบสุดท้ายจาก q1 และเก็บไว้เป็นองค์ประกอบที่แอบมอง จัดคิวกลับไปที่คิว q2 และสลับคิว q1 และ q2 ส่งคืนองค์ประกอบที่แอบดูที่เก็บไว้

ด้านล่างเป็นรหัสสำหรับอัลกอริทึมข้างต้น -

class MyStack {

    java.util.Queue<Integer> q1;
    java.util.Queue<Integer> q2;
    int SIZE = 0;

    /** Initialize your data structure here. */
    public MyStack() {
        q1 = new LinkedList<Integer>();
        q2 = new LinkedList<Integer>();

    }

    /** Push element x onto stack. */
    public void push(int x) {
        q1.add(x);
        SIZE ++;

    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        ensureQ2IsNotEmpty();
        int poppedEle = q1.remove();
        SIZE--;
        swapQueues();
        return poppedEle;
    }

    /** Get the top element. */
    public int top() {
        ensureQ2IsNotEmpty();
        int peekedEle = q1.remove();
        q2.add(peekedEle);
        swapQueues();
        return peekedEle;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty() && q2.isEmpty();

    }

    /** move all elements from q1 to q2 except last element */
    public void ensureQ2IsNotEmpty() {
        for(int i=0; i<SIZE-1; i++) {
            q2.add(q1.remove());
        }
    }

    /** Swap queues q1 and q2 */
    public void swapQueues() {
        Queue<Integer> temp = q1;
        q1 = q2;
        q2 = temp;
    }
}

นี่คือทางออกของฉัน ..

Concept_Behind :: push(struct Stack* S,int data):: ฟังก์ชั่นนี้จัดคิว องค์ประกอบแรกใน Q1 และพักใน Q2 pop(struct Stack* S) :: ถ้า Q2 ไม่ว่างเปล่าการถ่ายโอน elem ทั้งหมดเป็น Q1 และส่งคืนองค์ประกอบสุดท้ายใน Q2 อื่น (ซึ่งหมายความว่า Q2 ว่างเปล่า) ถ่ายโอน elem ทั้งหมดเป็น Q2 และ ส่งคืน elem สุดท้ายใน Q1

Efficiency_Behind :: push(struct Stack*S,int data):: O (1) // เนื่องจากการจัดคิวเดี่ยวต่อข้อมูล pop(struct Stack* S):: O (n) // เนื่องจากการโอนข้อมูล n-1 ที่เลวร้ายที่สุดต่อป๊อป

#include<stdio.h>
#include<stdlib.h>
struct Queue{
    int front;
    int rear;
    int *arr;
    int size;
    };
struct Stack {
    struct Queue *Q1;
    struct Queue *Q2;
    };
struct Queue* Qconstructor(int capacity)
{
    struct Queue *Q=malloc(sizeof(struct Queue));
    Q->front=Q->rear=-1;
    Q->size=capacity;
    Q->arr=malloc(Q->size*sizeof(int));
    return Q;
    }
int isEmptyQueue(struct Queue *Q)
{
    return (Q->front==-1);
    }
int isFullQueue(struct Queue *Q)
{
    return ((Q->rear+1) % Q->size ==Q->front);
    }
void enqueue(struct Queue *Q,int data)
{
    if(isFullQueue(Q))
        {
            printf("Queue overflow\n");
            return;}
    Q->rear=Q->rear+1 % Q->size;
    Q->arr[Q->rear]=data;
    if(Q->front==-1)
        Q->front=Q->rear;
        }
int dequeue(struct Queue *Q)
{
    if(isEmptyQueue(Q)){
        printf("Queue underflow\n");
        return;
        }
    int data=Q->arr[Q->front];
    if(Q->front==Q->rear)
        Q->front=-1;
    else
    Q->front=Q->front+1 % Q->size;
    return data;
    }
///////////////////////*************main algo****************////////////////////////
struct Stack* Sconstructor(int capacity)
{
    struct Stack *S=malloc(sizeof(struct Stack));
    S->Q1=Qconstructor(capacity);
    S->Q2=Qconstructor(capacity);
    return S;
}
void push(struct Stack *S,int data)
{
    if(isEmptyQueue(S->Q1))
        enqueue(S->Q1,data);
    else
        enqueue(S->Q2,data);
    }
int pop(struct Stack *S)
{
    int i,tmp;
    if(!isEmptyQueue(S->Q2)){
        for(i=S->Q2->front;i<=S->Q2->rear;i++){
            tmp=dequeue(S->Q2);
            if(isEmptyQueue(S->Q2))
                return tmp;
            else
                enqueue(S->Q1,tmp);
                }
            }
    else{
        for(i=S->Q1->front;i<=S->Q1->rear;i++){
            tmp=dequeue(S->Q1);
            if(isEmptyQueue(S->Q1))
                return tmp;
            else
                enqueue(S->Q2,tmp);
                }
            }
        }
////////////////*************end of main algo my algo************
///////////////*************push() O(1);;;;pop() O(n);;;;*******/////
main()
{
    int size;
    printf("Enter the number of elements in the Stack(made of 2 queue's)::\n");
    scanf("%d",&size);
    struct Stack *S=Sconstructor(size);
    push(S,1);
    push(S,2);
    push(S,3);
    push(S,4);
    printf("%d\n",pop(S));
    push(S,5);
    printf("%d\n",pop(S));
    printf("%d\n",pop(S));
    printf("%d\n",pop(S));
    printf("%d\n",pop(S));
    }

import java.util.LinkedList;
import java.util.Queue;


public class StackQueue {

    static Queue<Integer> Q1 = new LinkedList<Integer>();
    static Queue<Integer> Q2 = new LinkedList<Integer>();
    public static void main(String args[]) {



        push(24);
        push(34);
        push(4);
        push(10);
        push(1);
        push(43);
        push(21);
        System.out.println("Popped element is  "+pop());
        System.out.println("Popped element is  "+pop());
        System.out.println("Popped element is  "+pop());


    }

    public static void push(int data) {

        Q1.add(data);

    }

    public static int pop() {

        if(Q1.isEmpty()) {
        System.out.println("Cannot pop elements ,  Stack is Empty !!"); 
        return -1;
        }
        else
        {
        while(Q1.size() > 1) {
            Q2.add(Q1.remove());
        }
        int element = Q1.remove();
        Queue<Integer> temp = new LinkedList<Integer>();
        temp = Q1;
        Q1 = Q2;
        Q2 = temp;
        return element;
        }
    }
}

#include "stdio.h"
#include "stdlib.h"

typedef struct {
    int *q;
    int size;
    int front;
    int rear;
} Queue;
typedef struct {
    Queue *q1;
    Queue *q2;
} Stack;

int queueIsEmpty(Queue *q) {
    if (q->front == -1 && q->rear == -1) {
        printf("\nQUEUE is EMPTY\n");
        return 1;
    }
    return 0;
}
int queueIsFull(Queue *q) {
    if (q->rear == q->size-1) {
        return 1;
    }
    return 0;
}
int queueTop(Queue *q) {
    if (queueIsEmpty(q)) {
        return -1;
    }
    return q->q[q->front];
}
int queuePop(Queue *q) {
    if (queueIsEmpty(q)) {
        return -1;
    }
    int item = q->q[q->front];
    if (q->front == q->rear) {
        q->front = q->rear = -1;
    }
    else {
        q->front++;
    }
    return item;
}
void queuePush(Queue *q, int val) {
    if (queueIsFull(q)) {
        printf("\nQUEUE is FULL\n");
        return;
    }
    if (queueIsEmpty(q)) {
        q->front++;
        q->rear++;
    } else {
        q->rear++;
    }
    q->q[q->rear] = val;
}
Queue *queueCreate(int maxSize) {
    Queue *q = (Queue*)malloc(sizeof(Queue));
    q->front = q->rear = -1;
    q->size = maxSize;
    q->q = (int*)malloc(sizeof(int)*maxSize);
    return q;
}
/* Create a stack */
void stackCreate(Stack *stack, int maxSize) {
    Stack **s = (Stack**) stack;
    *s = (Stack*)malloc(sizeof(Stack));
    (*s)->q1 = queueCreate(maxSize);
    (*s)->q2 = queueCreate(maxSize);
}

/* Push element x onto stack */
void stackPush(Stack *stack, int element) {
    Stack **s = (Stack**) stack;
    queuePush((*s)->q2, element);
    while (!queueIsEmpty((*s)->q1)) {
        int item = queuePop((*s)->q1);
        queuePush((*s)->q2, item);
    }
    Queue *tmp = (*s)->q1;
    (*s)->q1 = (*s)->q2;
    (*s)->q2 = tmp;
}

/* Removes the element on top of the stack */
void stackPop(Stack *stack) {
    Stack **s = (Stack**) stack;
    queuePop((*s)->q1);
}

/* Get the top element */
int stackTop(Stack *stack) {
    Stack **s = (Stack**) stack;
    if (!queueIsEmpty((*s)->q1)) {
      return queueTop((*s)->q1);
    }
    return -1;
}

/* Return whether the stack is empty */
bool stackEmpty(Stack *stack) {
    Stack **s = (Stack**) stack;
    if (queueIsEmpty((*s)->q1)) {
        return true;
    }
    return false;
}

/* Destroy the stack */
void stackDestroy(Stack *stack) {
    Stack **s = (Stack**) stack;
    free((*s)->q1);
    free((*s)->q2);
    free((*s));
}

int main()
{
  Stack *s = NULL;
  stackCreate((Stack*)&s, 10);
  stackPush((Stack*)&s, 44);
  //stackPop((Stack*)&s);
  printf("\n%d", stackTop((Stack*)&s));
  stackDestroy((Stack*)&s);
  return 0;
}