c circular queue data structure
Ta vadnica o strukturi podatkov krožne čakalne vrste C ++ pojasnjuje, kaj je krožna vrsta, katere so osnovne operacije skupaj z implementacijo in aplikacijami:
Krožna vrsta je podaljšek osnovne čakalne vrste, o kateri smo že govorili. Znan je tudi kot 'Ring buffer'.
Kaj je Circular Queue v C ++?
Krožna vrsta je linearna podatkovna struktura, ki se uporablja za shranjevanje podatkovnih postavk. Deluje tako, da sledi pristopu FIFO (First In, First Out), zadnji položaj v čakalni vrsti pa je povezan nazaj na prvo mesto, da tvori krog.
=> Poiščite celotno serijo usposabljanj za C ++ tukaj
Kaj se boste naučili:
Krožna vrsta v jeziku C ++
Naslednji diagram prikazuje krožno čakalno vrsto.
Zgornja slika prikazuje krožno podatkovno strukturo velikosti 10. Prvih šest elementov je že v čakalni vrsti in vidimo, da sta prvi in zadnji položaj združena. Zaradi te ureditve prostor ne zaide, kot se to zgodi v linearni čakalni vrsti.
Predloga dokumenta strategije preizkusa za agilno metodologijo
V linearni čakalni vrsti, ko je vrsta zapolnjena, izbrišemo elemente z drugega konca, stanje čakalne vrste pa je še vedno prikazano kot polno in ne moremo vstaviti več elementov.
V krožno čakalno vrsto, ko je vrsta zapolnjena, in ko odstranimo elemente od spredaj, saj sta povezani zadnji in prvi položaj, lahko vstavimo elemente zadaj, ki so bili sproščeni z brisanjem elementa.
V naslednjem poglavju bomo spoznali osnovne operacije krožne čakalne vrste.
Osnovne operacije
Nekatere osnovne operacije krožne čakalne vrste so naslednje:
Spredaj: Vrne sprednji položaj v krožni čakalni vrsti.
Zadaj: Vrne zadnji položaj v krožni čakalni vrsti.
Čakalna vrsta: Enqueue (vrednost) se uporablja za vstavljanje elementa v krožno čakalno vrsto. Element je vedno vstavljen na zadnji konec čakalne vrste.
Za vstavljanje novega elementa v krožno čakalno vrsto sledimo naslednjemu zaporedju korakov.
# 1) Preverite, ali je krožna vrsta polna: preizkusite ((zadaj == VELIKOST-1 && spredaj == 0) || (zadaj == spredaj-1)), pri čemer je 'VELIKOST' velikost krožne čakalne vrste.
#two) Če je krožna vrsta polna, se prikaže sporočilo »Čakalna vrsta je polna«. Če čakalna vrsta ni polna, preverite, če (zadaj == VELIKOST - 1 && spredaj! = 0). Če je res, nastavite zadaj = 0 in vstavite element.
Dequeue: Dequeue funkcija se uporablja za brisanje elementa iz čakalne vrste. V krožni čakalni vrsti se element vedno izbriše s sprednjega dela. Spodaj je prikazano zaporedje postopkov odstranjevanja iz krožne čakalne vrste.
Koraki:
# 1) Preverite, ali je krožna vrsta prazna: preverite, če (spredaj == - 1).
#two) Če je prazen, prikažite sporočilo »Čakalna vrsta je prazna«. Če vrsta ni prazna, izvedite 3. korak.
# 3) Preverite, če (spredaj == zadaj). Če je res, potem nastavite spredaj = zadaj = -1, sicer preverite, če (spredaj == velikost-1), če je res, nastavite spredaj = 0 in vrnite element.
Ilustracija
V tem razdelku si bomo podrobno ogledali dodajanje / odstranjevanje elementov v krožni čakalni vrsti.
Upoštevajte naslednjo krožno čakalno vrsto s 5 elementi, kot je prikazano spodaj:
Nato v čakalno vrsto vstavimo element 1.
Nato vstavimo element z vrednostjo 3.
Ko vstavimo elemente, da bo čakalna vrsta polna, bo prikaz prikazan spodaj.
najboljša mesta za spletno gledanje anime
Zdaj iz čakalne vrste izbrišemo dva elementa, tj. Element 1 in element 3, kot je prikazano spodaj.
Nato v krožno čakalno vrsto vstavimo ali uvrstimo element 11, kot je prikazano spodaj.
Spet vstavimo element 13 v krožno čakalno vrsto. Čakalna vrsta bo videti, kot je prikazano spodaj.
Vidimo, da v krožni čakalni vrsti premikamo ali vstavljamo elemente v krog. Tako lahko porabimo ves prostor čakalne vrste, dokler se ne zapolni.
Izvajanje
Izvedimo krožno čakalno vrsto s pomočjo C ++.
#include using namespace std; class Queue { public: // Initialize front and rear int rear, front; // Circular Queue int size; int *circular_queue; Queue(int sz) { front = rear = -1; size = sz; circular_queue = new int(sz); } void enQueue(int elem); int deQueue(); void displayQueue(); }; /* Function to create Circular queue */ void Queue::enQueue(int elem) { if ((front == 0 && rear == size-1) || (rear == (front-1)%(size-1))) { cout<<'
Queue is Full'; return; } else if (front == -1) { /* Insert First Element */ front = rear = 0; circular_queue(rear) = elem; } else if (rear == size-1 && front != 0) { rear = 0; circular_queue(rear) = elem; } else { rear++; circular_queue(rear) = elem; } } // Function to delete element from Circular Queue int Queue::deQueue() { if (front == -1) { cout<<'
Queue is Empty'; return -1; } int data = circular_queue(front); circular_queue(front) = -1; if (front == rear) { front = -1; rear = -1; } else if (front == size-1) front = 0; else front++; return data; } //display elements of Circular Queue void Queue::displayQueue() { if (front == -1) { cout<<'
Queue is Empty'<= front) { for (int i = front; i <= rear; i++) cout< Zgoraj je prikazan rezultat krožnih čakalnih vrst. Najprej dodamo elemente in nato dva elementa odstranimo iz vrstnega reda ali odstranimo. Nato v krožno čakalno vrsto vstavimo ali uvrstimo še tri elemente. Vidimo, da so elementi v nasprotju z linearno čakalno vrsto dodani na koncu čakalne vrste.
Izvajanje povezanega seznama
Pogovorimo se o izvajanju krožne čakalne vrste na povezanem seznamu. Spodaj je prikazano izvajanje krožne čakalne vrste na seznamu C ++. Upoštevajte, da za predstavitev vsakega vozlišča uporabljamo struct. Operacije so enake kot prej, le da jih moramo v tem primeru izvesti glede na povezana vozlišča seznama.
Rezultat prikazuje krožno čakalno vrsto po operaciji čakalne vrste, odstranitev iz vrstnega reda in tudi po drugi operaciji čakalne vrste.
#include using namespace std; struct Node { int data; struct Node* link; }; struct PQueue { struct Node *front, *rear; }; /* this functions performs enqueue operation for circular queue */ void enQueue(PQueue *pq,int elem) { struct Node *temp = new Node; temp->data = elem; if (pq->front == NULL) pq->front = temp; else pq->rear->link = temp; pq->rear = temp; pq->rear->link = pq->front; } // This function performs dequeue operation for Circular Queue int deQueue(PQueue *pq) { if (pq->front == NULL) { cout<<'Queue is empty!!'; return -1; } int elem; // item to be dequeued // item is the last node to be deleted if (pq->front == pq->rear) { elem = pq->front->data; free(pq->front); pq->front = NULL; pq->rear = NULL; } else //more than one nodes { struct Node *temp = pq->front; elem = temp->data; pq->front = pq->front->link; pq->rear->link= pq->front; free(temp); } return elem ; } //display elements of Circular Queue void displayQueue(struct PQueue *pq) { struct Node *temp = pq->front; while (temp->link != pq->front) { cout<data<<' '; temp = temp->link; } cout<data; } //main program int main() { // Create a circular queue and initialize front and rear PQueue *pq = new PQueue; pq->front = pq->rear = NULL; // Insert/enqueue elements in Circular Queue enQueue(pq, 1); enQueue(pq, 3); enQueue(pq, 5); cout<<'
Circular Queue elements after enqueue operation: '; // Display elements in Circular Queue displayQueue(pq); // Delete/dequeue elements from Circular Queue cout<<'
Dequeued Item: '< Izhod:
Naslednja izvedba je program Java za prikaz krožne čakalne vrste s pomočjo povezanega seznama.
import java.util.* ; class Main { // Node structure static class Node { int data; Node link; } static class CQueue { Node front, rear; } // Enqueue operation for circular queue static void enQueue(CQueue cq, int value) { Node temp = new Node(); temp .data = value; if (cq .front == null) cq .front = temp; else cq .rear .link = temp; cq .rear = temp; cq .rear .link = cq .front; } // Dequeue operation for Circular Queue static int deQueue(CQueue cq) { if (cq .front == null) { System.out.printf ('Queue is empty!!'); return Integer.MIN_VALUE; } int value; // Value to be dequeued // the last node to be deleted if (cq.front == cq.rear) { value = cq.front.data; cq.front = null; cq.rear = null; } else { // There are more than one nodes Node temp = cq.front; value = temp.data; cq.front = cq.front.link; cq.rear.link= cq.front; } return value ; } // display the elements of Circular Queue static void displayQueue( CQueue cq) { Node temp = cq.front; while (temp.link != cq.front) { System.out.printf('%d ', temp.data); temp = temp.link; } System.out.printf('%d', temp.data); } /* main program */ public static void main(String args()) { // Create a queue and initialize front and rear CQueue cq = new CQueue(); cq.front = cq.rear = null; // Insert/enqueue elements in Circular Queue enQueue(cq, 2); enQueue(cq, 4); enQueue(cq, 6); System.out.print('
Circular Queue elements after Enqueue Operation:'); // Display elements in Circular Queue displayQueue(cq); // Delete/dequeue elements from Circular Queue System.out.printf('
Dequeued Item = %d', deQueue(cq)); System.out.printf('
Dequeued Item = %d', deQueue(cq)); System.out.print('
Circular Queue elements after Dequeue Operation:'); displayQueue(cq); enQueue(cq, 8); enQueue(cq, 10); System.out.print('
Circular Queue elements after second Enqueue Operation:'); displayQueue(cq); } } Izhod:
Rezultat zgornjega programa je podoben prejšnjemu programu.
Aplikacije
Pogovorimo se o nekaterih aplikacijah krožne čakalne vrste.
- Načrtovanje CPU: Proces operacijskega sistema, ki zahteva, da se zgodi kakšen dogodek ali da se nekateri drugi postopki dokončajo za izvajanje, se pogosto vzdržuje v krožni čakalni vrsti, tako da se izvedejo eden za drugim, ko so izpolnjeni vsi pogoji ali ko se zgodijo vsi dogodki.
- Upravljanje pomnilnika: Uporaba običajnih čakalnih vrst zapravlja prostor v pomnilniku, kot smo že omenili v zgornji razpravi. Uporaba krožne čakalne vrste za upravljanje pomnilnika je koristna za optimalno uporabo pomnilnika.
- Računalniško voden sistem prometne signalizacije: Računalniško podprti prometni signali so pogosto dodani v krožno čakalno vrsto, tako da se po preteku določenega časovnega intervala ponovijo.
Zaključek
Krožne čakalne vrste odpravijo glavno pomanjkljivost običajne čakalne vrste, pri kateri elementov ni mogoče vstaviti, ko je zadnji kazalec na koncu čakalne vrste, tudi če elemente izbrišemo in je prostor prazen. V krožni vrsti so elementi razporejeni krožno, tako da prostor sploh ni zapravljen.
Opazili smo tudi glavne operacije krožne čakalne vrste. Krožne čakalne vrste so večinoma uporabne za razporejanje in aplikacije, kot so sistemi prometne signalizacije, kjer signali svetijo v zavojih.
odpiranje datotek .7z na mac
V naslednji vadnici bomo spoznali dvojne čakalne vrste, ki jih preprosto imenujemo 'deque'.
=> Obiščite tukaj, če se želite naučiti C ++ iz nič
Priporočeno branje
- Struktura podatkov čakalne vrste v jeziku C ++ z ilustracijo
- Struktura podatkov prioritetne čakalne vrste v C ++ z ilustracijo
- Struktura podatkov krožnega povezanega seznama v jeziku C ++ z ilustracijo
- Data Mart Vadnica - Vrste, primeri in izvedba Data Mart
- Struktura podatkov skladov v C ++ z ilustracijo
- Primeri rudarjenja podatkov: najpogostejše uporabe podatkovnega rudarjenja 2021
- Struktura podatkov binarnega drevesa v jeziku C ++
- Prednostna vrsta v STL
