दो कतारों का उपयोग करके स्टैक को लागू करें

Question

इसी तरह का प्रश्न पहले भी वहाँ पूछा गया था , लेकिन यहाँ सवाल इसके उलट है, एक स्टैक के रूप में दो कतारों का उपयोग करते हुए। प्रश्न...

उनके मानक संचालन के साथ दो कतारों को देखते हुए ( enqueue, dequeue, isempty, size), एक ढेर अपने मानक संचालन के साथ लागू ( pop, push, isempty, size)।

समाधान के दो संस्करण होने चाहिए ।

• संस्करण A : किसी आइटम को धक्का देते समय स्टैक कुशल होना चाहिए; तथा
• संस्करण B : किसी आइटम को पॉप करते समय स्टैक कुशल होना चाहिए।

मुझे किसी भी विशिष्ट भाषा कार्यान्वयन से अधिक एल्गोरिथ्म में दिलचस्पी है। हालाँकि, मैं उन भाषाओं में व्यक्त किए गए समाधानों का स्वागत करता हूं जिनसे मैं परिचित हूं (जावा,सी#,अजगर,vb,जावास्क्रिप्ट,php)।

Comments

यकीन से यही है! CLRS - 10.1-6 ( tinyurl.com/clrs-ex-10-1-6 )

— rampion

एक ढेर, दो कतार एक सुरुचिपूर्ण समाधान देता है जिसमें Pop$ O (1) $ में Pushकाम करता है और $ O (\ sqrt {n}) $ amortized समय में काम करता है।

— hengxin

@ क्रैम्पियन अब इसका सीएलआरएस - 10.1-7। :)

— nsane

संबंधित पोस्ट। यह केवल एक कतार का उपयोग करके स्टैक को लागू करने के लिए एक और दिलचस्प समस्या है ।

— आरटीटी

Answer 1

संस्करण A (कुशल पुश):

• धक्का दें:
  • कतार में enqueue1
• पॉप:
  • जबकि क्यू 1 का आकार 1 से बड़ा है, क्यू 1 से पाइप ने आइटम को कतार 2 में हटा दिया
  • पंक्ति के अंतिम आइटम को हटाएं और वापस लौटें, फिर कतार 1 और कतार 2 के नामों को स्विच करें

संस्करण बी (कुशल पॉप):

• धक्का दें:
  • कतार में enqueue2
  • कतार 2 में कतार 1 की सभी वस्तुओं को संलग्न करें, फिर कतार 1 और कतार 2 के नामों को स्विच करें
• पॉप:
  • कतार से deeeue1

Comments

वर्जन B में समस्या आ रही है: क्या आपका मतलब कतार के सभी आइटम्स को क्यू 1 करने के लिए है क्यू कि अंतिम तत्व को छोड़कर (फिर q1 और q2 के नाम बदल सकते हैं)?

— इकारमैन

इकरमैन की टिप्पणी मेरे लिए मायने रखती है। उत्तर के संस्करण B को एक संपादन की आवश्यकता है। मेरे पास संपादन अनुमति नहीं है। किसी कृपया इस जवाब को संपादित कर सकते हैं?

— eeerahul

@ येराहुल: मैंने इसे फिर से जाँच लिया है, और उत्तर सही है। जिस समय इकारमैन को कतार 2 की सभी वस्तुओं को कतार 1 में लाना चाहते हैं, कतार 2 में केवल नई वस्तु है, इसलिए टिप्पणी का कोई मतलब नहीं है।

— श्वेन्ते

क्या संस्करण एक सही है? पुश 1, पुश 2, पुश 3, पुश 4. पॉप 4. पुश 5, पुश 6, पुश 7, पुश 8. पॉप 8. पॉप 7. पॉप। ऐसा लगता है कि एल्गोरिथ्म 7. के बजाय 3 पॉपिंग होगा। आपका एल्गोरिथ्म सही लगता है पहली नज़र क्योंकि हम संभवतः कारण के रूप में कर सकते हैं: मूल रूप से आप हमेशा कतार 1 में अंतिम enqueued तत्व popping होगा। लेकिन यह पिछले धक्का तत्व केवल अगर आप पहले कतार में था। यदि आप उत्तराधिकार में कई बार पॉपअप करते हैं, तो यह सच नहीं है।

— user127.0.0.1

@ user127.0.0.1: ऐसा लगता है कि आप प्रत्येक पॉप के अंत में कतारों को बदलना भूल गए हैं। एक आवेग है कि प्रत्येक धक्का और प्रत्येक पॉप के बाद, सभी आइटम कतार 1 में हैं, जबकि कतार 2 खाली है।

— Svante

Answer 2

ऐसा करने का सबसे आसान (और शायद केवल) तरीका नए तत्वों को खाली कतार में धकेलना है, और फिर दूसरे को हटाना और पहले की खाली कतार में प्रवेश करना है। इस तरह से नवीनतम हमेशा कतार के सामने होता है। यह संस्करण बी होगा, संस्करण ए के लिए आप पिछले एक को छोड़कर दूसरी कतार में तत्वों को हटाकर प्रक्रिया को उलट देंगे।

चरण ०:

"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 |   |   |  |   |   |   |   |   |
+---+---+---+---+---+  +---+---+---+---+---+

Comments

इसके लिए तर्क का कोई मतलब नहीं है। चरण 2 से चरण 3 पर ले जाएं। जब मैं 3 "पुश" करता हूं, तो मैं क्यू बी में तत्वों को इस तरह से कैसे हटा सकता हूं कि मुझे कतार ए में 3 2 1 मिलता है? यदि मैं A को A करने के लिए B को समाप्त करता हूं, तो मैं केवल 2, 1 में तत्व प्राप्त कर सकता हूं। 1. यदि मैं 3 जोड़ता हूं, तो मुझे आदेश 3, 1, 2 मिलेगा। यदि मैं अपना धक्का पहले लगाऊं, और फिर dequeue / enqueue, मैं प्राप्त करता हूं। 1, 2, 3.

— tsurantino

क्यों नहीं ईकाई ऑपरेशन को महंगा बनाने की तुलना में डीके ऑपरेशन को महंगा बनाया जाए?

— दिविज सहगल

Answer 3

हम इसे एक कतार से कर सकते हैं:

धक्का दें:

1. नया तत्व enqueue।
2. यदि nकतार में तत्वों की संख्या है, तो तत्व n-1बार निकालें और डालें ।

पॉप:

1. विपंक्ति

।

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));
  }
}

Answer 4

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());
    }
}

Comments

क्या कोई ऊपर दिए गए कोड में पुश विधि के पीछे लॉगिन की व्याख्या कर सकता है? जहां तक ​​मैंने समझा, लूप के लिए पहला सभी तत्वों को क्यू 2 में हटा रहा है जब तक कि क्यू 1 में एक तत्व शेष न हो। अगर मैं गलत हूं कृपया मुझे सही।

— जॉन

Answer 5

क्या हम एक स्टैक को लागू करने के लिए सिर्फ एक कतार का उपयोग कर सकते हैं? मैं दो कतारों का उपयोग कर सकता हूं, लेकिन एकल कतार पर विचार करना अधिक कुशल होगा। यहाँ कोड है:

    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();

    }

Comments

मुझे लगता है कि पॉप विधि में, लूप कंडीशन के लिए मैं होना चाहिए <queLower.Count - 2 जैसा कि आप वैरिएबल I को 0. के साथ प्रारंभ कर रहे हैं

— vignesh

Answer 6

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();
   }
}

Answer 7

यहाँ मेरा जवाब है - जहाँ 'पॉप' अक्षम है। लगता है कि तुरंत आने वाले सभी एल्गोरिदम में एन जटिलता है, जहां एन सूची का आकार है: चाहे आप 'पॉप' पर काम करना चुनते हैं या 'पुश' पर काम करना चाहते हैं

एल्गोरिथ्म जहां सूचियों का व्यापार वापस किया जाता है और चौथा बेहतर हो सकता है, क्योंकि आकार की गणना की आवश्यकता नहीं है, हालांकि आपको अभी भी लूप की आवश्यकता है और खाली की तुलना करें।

आप यह साबित कर सकते हैं कि इस एल्गोरिथ्म को N की तुलना में तेज़ी से नहीं लिखा जा सकता है कि कतार में अंतिम तत्व के बारे में जानकारी केवल कतार के आकार को जानने के माध्यम से उपलब्ध है, और आपको उस तत्व को प्राप्त करने के लिए डेटा को नष्ट करना होगा, इसलिए दूसरी कतार ।

इस तेजी को बनाने का एकमात्र तरीका पहली जगह में कतारों का उपयोग नहीं करना है।

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

Answer 8

यहां मेरा समाधान है जो औसत मामले में ओ (1) के लिए काम करता है। दो कतारें हैं: inऔर out। स्यूडोकोड बलो देखें:

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)

Comments

वहाँ आप 2 कतारों का उपयोग कर रहे हैं और 1 स्टैक का अनुकरण करने के लिए 1 स्टैक!

— बेनीबेला

क्या आप का मतलब है रिकर्सन स्टैक?

— व्लादिमीर कोस्त्युकोव

Answer 9

जैसा कि उल्लेख किया गया है, एक भी कतार चाल नहीं चलेगी? यह शायद कम व्यावहारिक है, लेकिन थोड़ा धीमा है।

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

pop(x):
dequeue()

Answer 10

यहाँ कुछ सरल छद्म कोड है, पुश ओ (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()

Answer 11

बता दें कि S1 और S2 कतारों के कार्यान्वयन में उपयोग किए जाने वाले दो स्टैक हैं।

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

हम सुनिश्चित करते हैं कि एक कतार हमेशा खाली रहे।

पुश ऑपरेशन: जो भी कतार खाली नहीं है, उसमें तत्व डालें।

• जांचें कि क्यू 1 क्यू खाली है या नहीं। यदि Q1 रिक्त है, तो इसमें तत्व संलग्न करें।
• अन्यथा Q1 में तत्व की गणना करें।

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

समय जटिलता: ओ (1)

पॉप ऑपरेशन: n-1 तत्वों को अन्य कतार में स्थानांतरित करें और पॉप ऑपरेशन करने के लिए कतार से अंतिम हटा दें।

• यदि क्यू 1 क्यू खाली नहीं है, तो एन -1 तत्वों को Q1 से Q2 में स्थानांतरित करें और फिर, Q1 के अंतिम तत्व को DeQueue करें और इसे वापस लौटाएं।
• यदि कतार Q2 खाली नहीं है, तो n-1 तत्वों को Q2 से Q1 में स्थानांतरित करें और फिर, Q2 के अंतिम तत्व को DeQueue करें और इसे वापस लौटाएं।

`

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) जैसा कि हर बार पॉप कहा जाता है, हम सभी तत्वों को एक कतार से ओटेर में स्थानांतरित कर रहे हैं।

Answer 12

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

Answer 13

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();
    }
}

Answer 14

यहाँ एक और समाधान है:

PUSH के लिए: कतार में पहले तत्व को जोड़ें 1. -जब दूसरा तत्व और इतने पर जोड़कर, तत्व को कतार 2 में पहले से डालें और फिर कतार 1 से कतार 2 तक के सभी तत्व को कॉपी करें। के लिए पीओपी सिर्फ आप पिछले तत्व डाला कतार से तत्व 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;
}'

एक समस्या है, मैं यह पता लगाने में सक्षम नहीं हूं कि कतारों का नाम कैसे बदला जाए ???

Answer 15

#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);
    }
}

Comments

कृपया कुछ शब्दों को समझाते हुए, कि यह कोड क्या है और यह कैसे ओपी को उसकी समस्या को हल करने में मदद करता है, कोड उदाहरण के साथ अत्यधिक सराहना की जाएगी :-)

— nIcE cOw

Answer 16

केवल एक कतार का उपयोग करके पायथन कोड

 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

Comments

कृपया एक कोड को उत्तर के रूप में डंप करने से बचने की कोशिश करें और यह समझाने की कोशिश करें कि यह क्या और क्यों करता है। आपका कोड उन लोगों के लिए स्पष्ट नहीं हो सकता है जिनके पास प्रासंगिक कोडिंग अनुभव नहीं है।

— फ्रिट्स

Answer 17

यहाँ सी # में पूरा काम कोड है:

इसे सिंगल क्यू के साथ लागू किया गया है,

धक्का दें:

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();
            }
        }
    }

Comments

वर्तमान में रखे गए तत्वों / कार्यों के कार्य के रूप में आपके कार्यान्वयन द्वारा अपेक्षित (परिशोधन / परिशोधन) समय पर टिप्पणी करने की आवश्यकता है?

— ग्रेबियार्ड

Answer 18

यहाँ बहुत सरल समाधान है जो एक क्यू का उपयोग करता है और स्टैक जैसी कार्यक्षमता देता है।

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());
    }


}

तो उपरोक्त श्रेणी में "कस्टमस्टैक" जो मैं कर रहा हूं वह सिर्फ खाली के लिए कतार की जांच कर रहा है, यदि खाली है तो एक डालें और फिर तब से वार्ड सम्मिलित करें और फिर डालें हटा दें। इस तर्क के द्वारा पहले अंतिम आएगा। उदाहरण: कतार में मैंने 1 डाला और अब डालने की कोशिश कर रहा है। 2. दूसरी बार 1 हटा दें और फिर से डालें ताकि यह रिवर्स ऑर्डर में हो जाए।

धन्यवाद।

Answer 19

नीचे एक बहुत ही सरल जावा सॉल्यूशन दिया गया है जो पुश ऑपरेशन को कुशल बनाता है।

कलन विधि -

1. दो कतारें q1 और q2 घोषित करें।

2. पुश ऑपरेशन - क्यू 1 को कतार में रखने के लिए एन्क्यू तत्व।

3. पॉप ऑपरेशन - सुनिश्चित करें कि कतार q2 खाली नहीं है। यदि यह खाली है, तो अंतिम तत्व को छोड़कर q1 से सभी तत्वों को हटा दें और एक-एक करके q2 में संलग्न करें। Q1 से अंतिम तत्व को हटाएं और इसे पॉपप किए गए तत्व के रूप में संग्रहीत करें। कतार q1 और q2 स्वैप करें। संग्रहीत पॉपअप तत्व लौटाएं।

4. पीक ऑपरेशन - सुनिश्चित करें कि कतार 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;
    }
}

Answer 20

यहाँ मेरा समाधान है ..

Concept_Behind :: push(struct Stack* S,int data):: यह फ़ंक्शन Q1 में पहला तत्व enqueue करता है और Q2 में आराम करता है pop(struct Stack* S):: अगर Q2 सभी हस्तांतरणों को Q1 में रिक्त नहीं करता है और अंतिम elem को Q2 में वापस करता है (जिसका अर्थ है कि Q2 खाली है) सभी elem का Q2 में स्थानांतरण करता है 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));
    }

Answer 21

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;
        }
    }
}

Comments

एक जावा लिंक्ड सूची एक ठीक काम के रूप में काम करती है। इस जवाब का कोई मतलब नहीं है।

— dfeuer

Answer 22

#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;
}

Comments

टिप्पणियों या स्पष्टीकरण के बिना कोड की एक दीवार एक खराब जवाब है।

— रिचर्ड