ડેકનો ઉપયોગ કરીને સ્ટેક અને કતાર લાગુ કરો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે કટ્ટરતા જીઇ હેલ્થકેર MAQ Myntra ક્યુઅલકોમ
ડેક્વી કતાર સ્ટેક

સમસ્યા નિવેદન

સમસ્યા "ડેકનો ઉપયોગ કરીને સ્ટેક અને કતાર લાગુ કરો" સ્ટેક અને કતારને ડ્યુ (ડબલી સમાપ્ત કતાર) નો ઉપયોગ કરીને અમલીકરણ માટે અલ્ગોરિધમ લખવા માટે જણાવે છે.

ઉદાહરણ (સ્ટેક)

Push(1)
Push(2)
Push(3)
Pop()
isEmpty()
Pop()
Size()
3
false
2
1

ઉદાહરણ (કતાર)

Enqueue(1)
Enqueue(2)
Enqueue(3)
Dequeue
isEmpty()
Size()
Dequeue()
1
false
2
2

 

અલ્ગોરિધમ

A deque(ડબ્લ્યુ એન્ડેડ કતાર) એ એક વિશેષ પ્રકારની કતાર છે જેમાં નિવેશ અને કાtionી નાખવા બંને છેડા પર કરી શકાય છે. ડેકની આ રસપ્રદ મિલકતનો ઉપયોગ સ્ટેક અથવા તેમાંથી કતારને લાગુ કરવા માટે થઈ શકે છે.
નીચેની તસવીર એક ડ્યુક બતાવે છે

ડેકનો ઉપયોગ કરીને સ્ટેક અને કતાર લાગુ કરો

સ્ટેક

સ્ટેક લાસ્ટ ઇન ફર્સ્ટ આઉટ (LIFO) ડેટા સ્ટ્રક્ચર છે, એટલે કે તત્વો તે જ બાજુથી બહાર નીકળી જાય છે જ્યાં તેમને દબાણ કરવામાં આવે છે. ચાલો સ્ટેક માટે પુશ અને પ popપ performપરેશન કરવા ડેકની આગળનો ઉપયોગ કરીએ.

દબાણ કરો (x)

કોઈ તત્વ x ને સ્ટેક પર દબાણ કરવા માટે, ફક્ત તનાવના ભાગને ડ્યુકની આગળના ભાગમાં ઉમેરો.

સમય જટિલતા = ઓ (1)

પ Popપ ()

પ Popપ operationપરેશન પુશની જેમ જ થાય છે, એટલે કે, સ્ટેકમાંથી કોઈ ઘટકને પ popપ કરવા માટે, તકતીના આગળના ભાગ પર હાજર તત્વને કા deleteી નાખો અને તેને પાછા કરો.

સમય જટિલતા = ઓ (1)

ખાલી છે()

જો ડ્યુક ખાલી છે સ્ટેક ખાલી છે નહીં તો તે નથી. તેથી ઇક્પ્ટી ઓફ ડ્યુક પરત કરો.

સમય જટિલતા = ઓ (1)

કદ ()

સ્ટેકનું કદ ડ્યુકના કદ જેટલું જ છે, તેથી ડ્યુકનું કદ પાછું આપવું.

સમય જટિલતા = ઓ (1)

કોડ

જાવા કોડ ડેકનો ઉપયોગ કરીને સ્ટેકને લાગુ કરવા
import java.util.Deque;
import java.util.LinkedList;
class StackUsingDeque {
    // deque used to implement stack
    private static Deque<Integer> deque;

    private static void push(int x) {
        // Add the element x to the front of Deque
        deque.addFirst(x);
    }

    private static int pop() {
        // if deque is not empty remove an element from the front of deque
        if (!deque.isEmpty()) {
            return deque.removeFirst();
        }
        return -1;
    }

    private static boolean isEmpty() {
        // stack is empty if deque is empty
        return deque.isEmpty();
    }

    private static int size() {
        // size of stack is same as size of Deque
        return deque.size();
    }

    public static void main(String[] args) {
        deque = new LinkedList<>();

        // Example
        push(1);
        push(2);
        push(3);
        System.out.println(pop());
        System.out.println(isEmpty());
        System.out.println(pop());
        System.out.println(size());
    }
}
3
false
2
1
સી ++ કોડને ડ્યુકનો ઉપયોગ કરીને સ્ટેકને અમલમાં મૂકવા માટે
#include <bits/stdc++.h>
using namespace std;

// deque used to implement stack
deque<int> dq;

void push(int x) {
    // Add the element x to the front of Deque
    dq.push_front(x);
}

int pop() {
    // if deque is not empty remove an element from the front of deque
    if (!dq.empty()) {
        int top = dq.front();
        dq.pop_front();
        return top;
    }
    return -1;
}

int size() {
    // size of stack is same as size of Deque
    return dq.size();
}

bool isEmpty() {
    // stack is empty if deque is empty
    return dq.empty();
}

int main() {
    // Example
    push(1);
    push(2);
    push(3);
    cout<<pop()<<endl;
    if (isEmpty()) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }
    cout<<pop()<<endl;
    cout<<size()<<endl;
    
    return 0;
}
3
false
2
1

કતાર

કતાર ફર્સ્ટ ઇન ફર્સ્ટ આઉટ (FIFO) ડેટા સ્ટ્રક્ચર છે, જે એન્ક્યુ અને ડેક્વી ઓપરેશંસ વિરુદ્ધ બાજુઓ પર કરવામાં આવે છે. ચાલો એન્ક્યુ operationપરેશન માટે Deque નો આગળનો ભાગ અને Dequeue ઓપરેશન માટે Deque નો પાછળનો ઉપયોગ કરીએ.

એન્ક્વિ (x)

કતારમાં એક તત્વ x ને કાqueવા ​​માટે, ફક્ત ડ્યુકની આગળના ભાગમાં તત્વ ઉમેરો.

સમય જટિલતા = ઓ (1)

Dequeue ()

કતારમાંથી કોઈ તત્વને શોધવા માટે, ડેકના પાછલા ભાગ પરના તત્વને દૂર કરો અને તેને પરત કરો.

સમય જટિલતા = ઓ (1)

ખાલી છે()

કતાર જો ડેક ખાલી છે, ખાલી છે, નહીં તો તે ખાલી છે. તેથી ઇક્પ્ટી ઓફ ડ્યુક પરત કરો.

સમય જટિલતા = ઓ (1)

કદ ()

કતારનું કદ ડ્યુકના કદ જેટલું જ છે, તેથી ડ્યુકનું કદ પાછું આપવું.

સમય જટિલતા = ઓ (1)

કોડ

JAVA કોડ, ડ્યુકનો ઉપયોગ કરીને કતાર લાગુ કરવા
import java.util.Deque;
import java.util.LinkedList;
class QueueUsingDeque {
    // deque used to implement queue
    private static Deque<Integer> deque;

    private static void enqueue(int x) {
        // add the element x at the front of deque
        deque.addFirst(x);
    }

    private static int dequeue() {
        // if deque is not empty remove and return the rear of deque
        if (!deque.isEmpty()) {
            return deque.removeLast();
        }
        return -1;
    }

    private static boolean isEmpty() {
        // queue is empty if deque is empty
        return deque.isEmpty();
    }

    private static int size() {
        // size of queue is same as size of deque
        return deque.size();
    }

    public static void main(String[] args) {
        deque = new LinkedList<>();

        // Example
        enqueue(1);
        enqueue(2);
        enqueue(3);
        System.out.println(dequeue());
        System.out.println(isEmpty());
        System.out.println(size());
        System.out.println(dequeue());
    }
}
1
false
2
2
સી ++ કોડનો ઉપયોગ ડ્યુકનો ઉપયોગ કરીને કતારને લાગુ કરવા માટે
#include <bits/stdc++.h>
using namespace std;

// deque used to implement queue
deque<int> dq;

void enqueue(int x) {
    // add the element x at the front of deque
    dq.push_front(x);
}

int dequeue() {
    // if deque is not empty remove and return the rear of deque
    if (!dq.empty()) {
        int front = dq.back();
        dq.pop_back();
        return front;
    }
    return -1;
}

int size() {
    // size of queue is same as size of deque
    return dq.size();
}

bool isEmpty() {
    // queue is empty if deque is empty
    return dq.empty();
}

int main() {
    // Example
    enqueue(1);
    enqueue(2);
    enqueue(3);
    cout<<dequeue()<<endl;
    if (isEmpty()) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }
    cout<<size()<<endl;
    cout<<dequeue()<<endl;
    
    return 0;
}
1
false
2
2