Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ प्रोग्राम: प्रायोरिटी क्यू इम्प्लीमेंटेशन

क्यू जिसे FIFO के रूप में इम्प्लीमेंट किया जाता है जहां सम्मिलन एक छोर (रियर) पर होता है और विलोपन दूसरे छोर (फ्रंट) से होता है। पहला एलिमेंट जो प्रवेश करता है वह पहले डिलीट होता है।

क्यू ऑपरेशन्स हैं:

  • EnQueue (int data): रियर छोर पर सम्मिलन
  • int DeQueue(): फ्रंट छोर से विलोपन

लेकिन एक प्रायोरिटी क्यू फर्स्ट-इन-फर्स्ट-आउट का पालन नहीं करता, बल्कि प्रत्येक एलिमेंट की तात्कालिकता के आधार पर प्राथमिकता होती है।

समान प्राथमिकता वाले आइटम्स को फर्स्ट-इन-फर्स्ट-आउट सेवा आधार पर संसाधित किया जाता है।

उच्च प्राथमिकता वाला आइटम निम्न प्राथमिकता वाले अन्य आइटम्स से पहले संसाधित होता है।

क्लास विवरण

Begin
    class Priority_Queue में निम्नलिखित फ़ंक्शन्स हैं:
    function insert() प्रायोरिटी क्यू में आइटम्स को उनकी प्राथमिकताओं के साथ सम्मिलित करने के लिए:
        1) यदि क्यू खाली है तो क्यू के बाएं छोर से डेटा सम्मिलित करें।
        2) यदि क्यू में कुछ नोड्स हैं तो नए नोड को उन नोड्स के अंत में सम्मिलित करें जिनकी प्राथमिकता नए नोड के समान है और उन सभी नोड्स से पहले जिनकी प्राथमिकता नए नोड की वर्तमान प्राथमिकता से कम है।
    function del() क्यू से आइटम्स डिलीट करने के लिए।
    यदि क्यू पूरी तरह खाली है, तो अंडरफ्लो प्रिंट करें अन्यथा फ्रंट एलिमेंट डिलीट करें और फ्रंट अपडेट करें।
End

उदाहरण

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;

struct n {
    int p;
    int info;
    struct n *l;
};

class Priority_Queue {
private:
    n *f;
public:
    Priority_Queue() {
        f = NULL;
    }
    void insert(int i, int p) {
        n *t, *q;
        t = new n;
        t->info = i;
        t->p = p;
        if (f == NULL || p < f->p) {
            t->l = f;
            f = t;
        } else {
            q = f;
            while (q->l != NULL && q->l->p <= p)
                q = q->l;
            t->l = q->l;
            q->l = t;
        }
    }
    void del() {
        n *t;
        if (f == NULL) {
            cout << "क्यू अंडरफ्लो\n";
        } else {
            t = f;
            cout << "डिलीट किया गया आइटम: " << t->info << endl;
            f = f->l;
            free(t);
        }
    }
    void show() {
        n *ptr;
        ptr = f;
        if (f == NULL)
            cout << "क्यू खाली है\n";
        else {
            cout << "क्यू है:\n";
            cout << "प्राथमिकता आइटम\n";
            while (ptr != NULL) {
                cout << ptr->p << " " << ptr->info << endl;
                ptr = ptr->l;
            }
        }
    }
};

int main() {
    int c, i, p;
    Priority_Queue pq;
    do {
        cout << "1. सम्मिलित करें\n";
        cout << "2. डिलीट करें\n";
        cout << "3. प्रदर्शित करें\n";
        cout << "4. बाहर निकलें\n";
        cout << "अपनी पसंद दर्ज करें: ";
        cin >> c;
        switch (c) {
            case 1:
                cout << "क्यू में जोड़ने के लिए आइटम मान दर्ज करें: ";
                cin >> i;
                cout << "इसकी प्राथमिकता दर्ज करें: ";
                cin >> p;
                pq.insert(i, p);
                break;
            case 2:
                pq.del();
                break;
            case 3:
                pq.show();
                break;
            case 4:
                break;
            default:
                cout << "गलत पसंद\n";
        }
    } while (c != 4);
    return 0;
}

आउटपुट

1. सम्मिलित करें
2. डिलीट करें
3. प्रदर्शित करें
4. बाहर निकलें
अपनी पसंद दर्ज करें: 1
क्यू में जोड़ने के लिए आइटम मान दर्ज करें: 7
इसकी प्राथमिकता दर्ज करें: 2
...
क्यू है:
प्राथमिकता आइटम
1 6
2 7
3 3
3 4
  1. C++ में सीजर सिफर (Caesar Cipher) का कार्यान्वयन C++ में सीजर सिफर (Caesar Cipher) का कार्यान्वयन

    यह एक मोनो-अल्फाबेटिक सिफर है जिसमें प्लेनटेक्स्ट के प्रत्येक अक्षर को दूसरे अक्षर द्वारा प्रतिस्थापित किया जाता है ताकि सिफरटेक्स्ट बन सके। यह सब्स्टीट्यूशन सिफर योजना का सबसे सरल रूप है। इस क्रिप्टोसिस्टम को आमतौर पर शिफ्ट सिफर के रूप में संदर्भित किया जाता है। अवधारणा प्रत्येक अल्फाबेट को दूसरे

  1. C++ में AVL ट्री को लागू करना C++ में AVL ट्री को लागू करना

    AVL ट्री एक सेल्फ-बैलेंसिंग बाइनरी सर्च ट्री है जहां सभी नोड्स के लिए बाएं और दाएं सबट्री की ऊंचाई का अंतर एक से अधिक नहीं हो सकता।ट्री रोटेशन एक ऑपरेशन है जो AVL ट्री पर एलिमेंट्स के क्रम में हस्तक्षेप किए बिना स्ट्रक्चर को बदलता है। यह ट्री में एक नोड को ऊपर ले जाता है और एक नोड को नीचे। इसका उपयो

  1. - C++ प्रोग्राम: ऐरे का उपयोग करके क्यू कार्यान्वयन

    ऐरे आधारित क्यू क्यू FIFO सिद्धांत का पालन करती है। ऐरे कार्यान्वयन में निश्चित आकार की सरणी और front/rear सूचकांक का उपयोग किया जाता है। C++ प्रोग्राम उदाहरण rear) { cout << Queue Underflow << endl; return; } else { cout << Element deleted: <<