Deque භාවිතා කරමින් තොග සහ පෝලිම් ක්‍රියාත්මක කරන්න


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ උන්මත්තකයෝ GE සෞඛ්යාරක්ෂණය MAQ මින්ට්‍රා Qualcomm
Dequeue පෝලිමේ අඩුක්කුව

ගැටළු ප්රකාශය

“ඩෙක් භාවිතා කරමින් තොග සහ පෝලිම් ක්‍රියාත්මක කිරීම” යන ගැටළුවෙහි දැක්වෙන්නේ ඩෙක් (ද්විත්ව නිමවූ පෝලිම්) භාවිතා කරමින් ස්ටැක් සහ පෝලිම් ක්‍රියාත්මක කිරීම සඳහා ඇල්ගොරිතමයක් ලිවීමයි.

උදාහරණය (සිරස්)

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(Doubly Ended Queue) යනු විශේෂ පෝලිම් වර්ගයක් වන අතර එහි කෙළවරේ ඇතුළු කිරීම සහ මකා දැමීම සිදු කළ හැකිය. ඩෙක් හි මෙම සිත්ගන්නාසුලු දේපල තොගයක් හෝ පෝලිමක් ක්‍රියාත්මක කිරීමට භාවිතා කළ හැකිය.
පහත රූපයේ දැක්වෙන්නේ ඩෙක්,

Deque භාවිතා කරමින් තොග සහ පෝලිම් ක්‍රියාත්මක කරන්න

අඩුක්කුව

අඩුක්කුව යනු අන්තිම පළමු (LIFO) දත්ත ව්‍යුහයකි, එනම් මූලද්‍රව්‍ය තල්ලු කරනු ලබන එකම පැත්තෙන් පිටතට පැමිණේ. තොග සඳහා තල්ලු සහ පොප් ක්‍රියාකාරිත්වය සිදු කිරීම සඳහා අපි ඩෙක්ගේ ඉදිරිපස භාවිතා කරමු.

තල්ලු කරන්න (x)

X මූලද්‍රව්‍යයක් තොගයට තල්ලු කිරීම සඳහා, Deque හි ඉදිරිපස x මූලද්‍රව්‍යය එක් කරන්න.

කාල සංකීර්ණතාව = ඕ (1)

පොප් ()

පොප් ක්‍රියාකාරිත්වය සිදුවන්නේ පුෂ්ගේ පැත්තෙන් ය, එනම්, මූලද්‍රව්‍යයක් තොගයෙන් පොප් කිරීම, ඩෙක් ඉදිරිපස ඇති මූලද්‍රව්‍යය මකා දමා එය ආපසු ලබා දීම.

කාල සංකීර්ණතාව = ඕ (1)

හිස්()

Deque හිස් නම් තොගය හිස් ය, එසේ නොවේ. එබැවින් isEmpty of Deque වෙත ආපසු යන්න.

කාල සංකීර්ණතාව = ඕ (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) දත්ත ව්‍යුහය වන අතර, ප්‍රතිවිරුද්ධ පැතිවලින් එන්කියු සහ ඩියුකියු මෙහෙයුම් සිදු කරනු ලැබේ. එන්කියු මෙහෙයුම සඳහා ඩෙක්ගේ ඉදිරිපස සහ ඩියුක් මෙහෙයුම් සඳහා ඩෙක්ගේ පිටුපස භාවිතා කරමු.

එන්කියු (x)

පෝලිම්වල x මූලද්‍රව්‍යයක් ගණනය කිරීම සඳහා, ඩියුක් ඉදිරිපස ඇති මූලද්‍රව්‍යය එක් කරන්න.

කාල සංකීර්ණත්වය = ඕ (1)

Dequeue ()

පෝලිමේ සිට මූලද්‍රව්‍යයක් ඉවත් කිරීම සඳහා, ඩෙක් පිටුපස ඇති මූලද්‍රව්‍යය ඉවත් කර එය ආපසු ලබා දෙන්න.

කාල සංකීර්ණතාව = ඕ (1)

හිස්()

එම පෝලිමේ Deque හිස් නම් හිස් ය, එසේ නොවේ. එබැවින් isEmpty of Deque වෙත ආපසු යන්න.

කාල සංකීර්ණතාව = ඕ (1)

ප්‍රමාණය ()

පෝලිමේ ප්‍රමාණය ඩෙක්ගේ ප්‍රමාණයට සමාන වේ, එබැවින් ඩෙක් ප්‍රමාණය නැවත ලබා දෙන්න.

කාල සංකීර්ණතාව = ඕ (1)

කේතය

ඩෙක් භාවිතා කරමින් පෝලිම් ක්‍රියාත්මක කිරීම සඳහා ජාවා කේතය
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
Deque භාවිතා කර පෝලිම් ක්‍රියාත්මක කිරීමට C ++ කේතය
#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