দুটি সারি ব্যবহার করে স্ট্যাক প্রয়োগ করুন

Question

অনুরূপ প্রশ্ন আগে সেখানে জিজ্ঞাসা করা হয়েছিল , তবে এখানে প্রশ্নটি এর বিপরীত, স্ট্যাক হিসাবে দুটি সারি ব্যবহার করে। প্রশ্নটি...

তাদের মান অপারেশন সঙ্গে দুই সারি দেওয়া ( enqueue, dequeue, isempty, size), একটি স্ট্যাক তার আদর্শ অপারেশন সঙ্গে বাস্তবায়ন ( pop, push, isempty, size)।

সমাধান দুটি সংস্করণ থাকা উচিত ।

• সংস্করণ এ : কোনও আইটেমটি চাপ দেওয়ার সময় স্ট্যাকটি দক্ষ হওয়া উচিত; এবং
• সংস্করণ বি : কোনও আইটেম পপ করার সময় স্ট্যাকটি দক্ষ হওয়া উচিত।

আমি নির্দিষ্ট ভাষা প্রয়োগের চেয়ে অ্যালগরিদমে আগ্রহী। তবে আমি যে ভাষাগুলির সাথে পরিচিত সেগুলিতে প্রকাশিত সমাধানগুলিকে স্বাগত জানাই (জাভা,C #,পাইথন,VB,জাভাস্ক্রিপ্ট,পিএইচপি)।

Comments

এটা নিশ্চিত! CLRS - 10.1-6 ( tinyurl.com/clrs-ex-10-1-6 )

— rampion

ওয়ান স্ট্যাক, টু কুইউস একটি মার্জিত সমাধান দেয় যা Pop$ O (1) Pushin এ কাজ করে এবং $ O (q sqrt {n}) or মোড়িত সময়ে কাজ করে।

— হেনগ্সিন

@ আরম্পিয়ান এখন এর সিএলআরএস - 10.1-7। :)

— নসনে

সম্পর্কিত পোস্ট এখানে কেবলমাত্র একটি সারি ব্যবহার করে স্ট্যাক প্রয়োগ করতে এটি আর একটি আকর্ষণীয় সমস্যা ।

— আরবিটি

Answer 1

সংস্করণ এ (দক্ষ ধাক্কা):

• ধাক্কা:
  • কাতারে এনকুই 1
• পপ:
  • সারি 1-এর আকার 1 এর চেয়ে বড়, পাইপ 1 থেকে কাতারে 2 আইটেমগুলি সরিয়ে নিয়েছে
  • সারিবদ্ধ 1 এবং সারিবদ্ধ 2 এর শেষ আইটেমটি ফিরিয়ে আনুন, তারপরে কিউ 1 এবং কাতার 2 এর নাম পরিবর্তন করুন

সংস্করণ বি (দক্ষ পপ):

• ধাক্কা:
  • সারিবদ্ধ 2 সারিবদ্ধ
  • সারিবদ্ধ সমস্ত আইটেমকে কাতারে 2 এ সারিবদ্ধ করুন, তারপরে কিউ 1 এবং কাতার 2 এর নাম স্যুইচ করুন
• পপ:
  • 1 সারি থেকে deqeue

Comments

সংস্করণ বি সমস্যাটি মনে হচ্ছে: আপনি কি قطارের সমস্ত আইটেমকে শেষ উপাদানটি বাদ দিয়ে কাতার 1-এ সরিয়েছেন (তারপরে কিউ 1 এবং কি 2 এর নাম স্যুইচ করবেন)?

— আইসরম্যান

আইসরম্যানের মন্তব্যটি আমার কাছে বোধগম্য। উত্তরের সংস্করণ বি এর একটি সম্পাদনা দরকার। আমার সম্পাদনার অনুমতি নেই। কেউ দয়া করে এই উত্তরটি সম্পাদনা করতে পারেন?

— আইরাহুল

@ আইরাহুল: আমি আবার এটি পরীক্ষা করে দেখেছি, এবং উত্তরটি সঠিক। যে সময় আইসারম্যান মনে হয় যে সারিবদ্ধভাবে সমস্ত কিউ 2 আইটেমকে কাতারে 1 তৈরি করতে চান, ক্যু 2 কেবলমাত্র নতুন আইটেমকে ধারণ করে, তাই মন্তব্যে কোনও অর্থ হয় না ।

— সোভান্তে

সংস্করণ কি সঠিক? 1 চাপুন, 2 চাপুন, 3 চাপুন, 4 চাপুন। পপ 4. পুশ 5, ধাক্কা 6, ধাক্কা 8 পপ 8. পপ 7. পঠন 7 মনে হয় যে অ্যালগোরিদম পরিবর্তে 3 পপিং হবে 7 পরিবর্তে আপনার অ্যালগরিদম ঠিক বলে মনে হচ্ছে প্রথম নজরে কারণ আমরা সম্ভবত কারণ হিসাবে চিহ্নিত করতে পারি: মূলত আপনি সর্বদা 1 সারিতে সর্বশেষ এনকোয়েটিড উপাদানটি পপ করে যাবেন তবে আপনি যদি আগে সারি করতেন তবে এটিই সর্বশেষ ধাক্কা দেওয়া উপাদান। যদি আপনি পর পর একাধিকবার পপ করেন, তবে এটি সত্য হওয়ার দরকার নেই।

— ব্যবহারকারী 127.0.0.1

@ ব্যবহারকারী 127.0.0.1: দেখে মনে হচ্ছে আপনি প্রতিটি পপ শেষে সারিগুলি স্যুইচ করতে ভুলে গেছেন। সেখানে একটি আক্রমণকারী রয়েছে যে প্রতিটি ধাক্কা এবং প্রতিটি পপ পরে, সমস্ত আইটেম সারি 1 এ থাকে, যখন কাতার 2 খালি থাকে।

— সোভান্তে

Answer 2

এটি করার সহজতম (এবং সম্ভবত কেবল) উপায়টি হ'ল নতুন উপাদানগুলিকে খালি কাতারে চাপানো এবং তারপরে অন্যটিকে সন্ধান করে এবং পূর্ববর্তী খালি কাতারে সন্ধান করা। এই ভাবে সর্বশেষতম সর্বদা সারির সামনের দিকে থাকে। এটি সংস্করণ বি হবে, সংস্করণ এ এর ​​জন্য আপনি কেবলমাত্র শেষটি বাদে উপাদানগুলিকে দ্বিতীয় কাতারে চিহ্নিত করে প্রক্রিয়াটি বিপরীত করুন।

পদক্ষেপ 0:

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

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

ধাপ 1:

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

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

ধাপ ২:

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

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

ধাপ 3:

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

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

Comments

এটির জন্য যুক্তি কোনও অর্থ দেয় না। পদক্ষেপ 2 থেকে 3 য় ধাপে যান When আমি যখন "ধাক্কা" 3 দিই, আমি কীভাবে কুই বিতে উপাদানগুলি এমনভাবে সজ্জিত করতে পারি যে আমি সারিতে A তে 3 2 1 পেয়েছি? যদি আমি এটিকে সারিবদ্ধ করার জন্য বি কে শনাক্ত করি তবে আমি কেবল 2, 1 ক্রমে উপাদানগুলি পেতে পারি If আমি যদি পরে 3 যুক্ত করি তবে আমি আদেশ 3, 1, 2 পেয়ে যাব my 1, 2, 3

— tsurantino

এনেকিউ অপারেশন ব্যয়বহুল করার চেয়ে ডেক অপারেশনকে ব্যয়বহুল কেন করবেন না?

— ডিভিজ সেহগাল

Answer 3

আমরা এক সারিতে এটি করতে পারি:

ধাক্কা:

1. নতুন উপাদান সারিবদ্ধ করুন।
2. যদি nসারিতে থাকা উপাদানগুলির সংখ্যা হয়, তবে উপাদান n-1সময় সরিয়ে sertোকান ।

পপ:

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

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

উপরের কোডটিতে পুশ পদ্ধতির পিছনে যে কেউ লগইনটি ব্যাখ্যা করতে পারে? যতদূর আমি বুঝতে পেরেছি, লুপের জন্য প্রথমটি Q2 এ সমস্ত উপাদান সরিয়ে দিচ্ছে যতক্ষণ না Q1 এ একটি উপাদান অবশিষ্ট থাকে। আমি ভুল হলে আমাকে সংশোধন করুন।

— জন

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

আমি পপ পদ্ধতিতে অনুমান করি, লুপের শর্তটি আমি <কুইলওওয়ার.কাউন্ট - 2 হওয়া উচিত কারণ আপনি 0 দিয়ে ভেরিয়েবলটি শুরু করছেন

— বিগ্নেশ

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

এখানে আমার উত্তর - যেখানে 'পপ' অদক্ষ। দেখে মনে হচ্ছে যে সমস্ত অ্যালগরিদমগুলি অবিলম্বে মনে আসে তাদের এন জটিলতা রয়েছে, যেখানে এন তালিকার মাপ: আপনি 'পপ' এ কাজ করা বেছে নেবেন বা 'পুশ' তে কাজ করবেন কিনা

তালিকার পিছনে এবং চতুর্থ তালিকাগুলি যেখানে অ্যালগরিদম আরও ভাল হতে পারে, একটি আকার গণনার প্রয়োজন হয় না, যদিও আপনাকে এখনও ফাঁকা এবং খালি সাথে তুলনা করতে হবে।

আপনি প্রমাণ করতে পারেন যে এই অ্যালগরিদমটি এন এর চেয়ে দ্রুত আর লেখা যায় না যে একটি সারিতে থাকা শেষ উপাদানটি সম্পর্কিত তথ্য কেবল সারিটির আকার জানার মাধ্যমেই পাওয়া যায় এবং সেই উপাদানটিতে পৌঁছানোর জন্য আপনাকে অবশ্যই ডেটা নষ্ট করতে হবে, সুতরাং দ্বিতীয় সারিতে ।

এটিকে দ্রুত করার একমাত্র উপায় হ'ল প্রথম স্থানে সারি ব্যবহার না করা।

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

সেখানে আপনি 1 টি স্ট্যাকের অনুকরণে 2 টি সারি এবং 1 টি স্ট্যাক ব্যবহার করছেন!

— বেনিবেলা

আপনি বোঝাতে চান পুনরাবৃত্তি স্ট্যাক?

— ভ্লাদিমির কোস্ট্যুকভ

Answer 9

যেমনটি উল্লেখ করা হয়েছে, একক কিউ চালাবেন না? এটি সম্ভবত কম ব্যবহারিক তবে কিছুটা চটচটে।

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

pop(x):
dequeue()

Answer 10

এখানে কিছু সাধারণ সিউডো কোড রয়েছে, পুশ হল ও (এন), পপ / পিক হল ও (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

এস 1 এবং এস 2 কে সারি প্রয়োগের ক্ষেত্রে দুটি স্ট্যাক হিসাবে ব্যবহার করা যাক।

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

আমরা নিশ্চিত করে নিই যে একটি সারিতে সর্বদা ফাঁকা থাকে।

পুশ অপারেশন: যে কোনও সারি খালি নেই, এতে উপাদানটি sertোকান।

• কিউ কিউ 1 খালি কিনা তা পরীক্ষা করে দেখুন। যদি Q1 খালি থাকে তবে এর মধ্যে উপাদানটি সজ্জিত করুন।
• অন্যথায় উপাদানটিকে Q1 এ এনকিউ করুন।

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

সময় জটিলতা: ও (1)

পপ অপারেশন: অন্যান্য কাতারে এন -1 উপাদান স্থানান্তর করুন এবং পপ ক্রিয়াকলাপ সম্পাদনের জন্য সারিতে সর্বশেষটি মুছুন।

• যদি কিউ কিউ 1 খালি না থাকে তবে Q-1 থেকে Q2 এ n-1 উপাদানগুলি স্থানান্তর করুন এবং তারপরে Q1 এর শেষ উপাদানটি DeQueue করুন এবং এটি ফিরিয়ে দিন।
• যদি ক্যু Q2 খালি না থাকে তবে Q2 থেকে Q1 এ n-1 উপাদানগুলি স্থানান্তর করুন এবং তারপরে 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);
} }

সময় জটিলতা: পপ অপারেশন চলমান সময় ও (এন) হিসাবে প্রতিটি সময় পপ বলা হয়, আমরা একটি উপাদান থেকে একটি সারিতে সমস্ত উপাদান স্থানান্তরিত হয়।

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

এখানে আরও একটি সমাধান রয়েছে:

পুশের জন্য: কাতারে প্রথম উপাদান যুক্ত করুন--দ্বিতীয় উপাদান যুক্ত করার পরে এবং দ্বিতীয়টি যুক্ত করুন, প্রথমে প্রথম সারিতে উপাদানটি তৈরি করুন এবং তারপরে সমস্ত উপাদানটি সারি 1 থেকে কাতারে 2 অনুলিপি করুন। - পিওপি-র জন্য সারি থেকে উপাদানটি বের করার জন্য আপনার কাছ থেকে শেষ উপাদানটি sertedোকানো হয়েছে।

সুতরাং,

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

এই কোডটি কী এবং কীভাবে এই সমস্যাটি ওপিকে তার সমস্যা সমাধানে সহায়তা করতে সক্ষম হবে তা ব্যাখ্যা করে কিছু শব্দ দয়া করে কোড উদাহরণ সহ বরাবর প্রশংসা করা হবে :-)

— n

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 টি nowোকিয়েছি এবং এখন 2 টি সন্নিবেশ করানোর চেষ্টা করছি। দ্বিতীয় বার 1 টি সরান এবং আবার সন্নিবেশ করান যাতে এটি বিপরীত ক্রমে হয়।

ধন্যবাদ.

Answer 19

নীচে একটি খুব সহজ জাভা সমাধান যা পুশ অপারেশন দক্ষতার জন্য সমর্থন করে।

অ্যালগরিদম -

1. দুটি সারি Q1 এবং কি 2 ঘোষণা করুন la

2. ক্রিয়াকলাপ পুশ করুন - কিউ 1 সারিতে উপাদানটিকে সারিবদ্ধ করুন।

3. পপ অপারেশন - নিশ্চিত করুন যে সারি কিউ 2 খালি নেই। যদি এটি খালি থাকে, তবে শেষ উপাদান ব্যতীত Q1 থেকে সমস্ত উপাদানগুলি চিহ্নিত করুন এবং একে একে Q2 এ সারিবদ্ধ করুন। কিউ 1 থেকে শেষ উপাদানটি সনাক্ত করুন এবং পপড উপাদান হিসাবে এটি সংরক্ষণ করুন। কিউ 1 ও কিউ 2 স্যুইপ করুন। সঞ্চিত পপড উপাদানটি ফিরিয়ে দিন।

4. পিক অপারেশন - নিশ্চিত করুন যে সারি কিউ 2 খালি নেই। যদি এটি খালি থাকে, তবে শেষ উপাদান ব্যতীত Q1 থেকে সমস্ত উপাদানগুলি চিহ্নিত করুন এবং একে একে Q2 এ সারিবদ্ধ করুন। কিউ 1 থেকে শেষ উপাদানটি সনাক্ত করুন এবং এটি উঁকি দেওয়া উপাদান হিসাবে সংরক্ষণ করুন। এটিকে পুনরায় কিউ 2-এ সজ্জিত করুন এবং কিউ 1 কিউ এবং কি 2 কে স্যুপ করুন। সঞ্চিত উঁকি দেওয়া উপাদানটি ফিরিয়ে দিন।

নীচে উপরে অ্যালগরিদমের কোড রয়েছে -

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

এখানে আমার সমাধান ..

কনসেপ্ট_বিহিন্ড :: push(struct Stack* S,int data):: এই ফাংশনটি Q1 এ প্রথম উপাদান তৈরি করে এবং কিউ 2 এ বিশ্রাম দেয় pop(struct Stack* S):: যদি Q2 স্থানটি খালি না করে সমস্ত এলিমিকে Q1 এ স্থানান্তর করে এবং Q2- এ শেষ এলেমটি ফেরত আসে (যার অর্থ Q2 খালি) সমস্ত এলিমিকে Q2 তে স্থানান্তর করে এবং Q1 এ শেষ এলেম ফেরত দেয়

দক্ষতা_বহীদ :: push(struct Stack*S,int data):: ও (১) // যেহেতু ডেটা প্রতি একক pop(struct Stack* S)এনকুই :: ও (এন) // যেহেতু ট্রান্সফার্স পপ প্রতি সবচেয়ে খারাপ এন -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

একটি জাভা লিঙ্কযুক্ত তালিকা একটি deque হিসাবে ঠিক ফাংশন। এই উত্তরটি বোঝা যায় না।

— 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

কোনও মন্তব্য বা ব্যাখ্যা ছাড়াই কোডের একটি প্রাচীর একটি খারাপ উত্তর answer

— রিচার্ড