Varför introducerades begreppet cirkulär kö?

Det fanns en begränsning i arrayimplementeringen av

Som vi kan se i bilden ovan är den bakre i den sista positionen i kön och den främre pekar någonstans istället för 0^thplacera. I ovanstående array finns det bara två element och övriga tre positioner är tomma. Den bakre är i den sista positionen i kön; om vi försöker infoga elementet kommer det att visa att det inte finns några tomma utrymmen i kön. Det finns en lösning för att undvika sådant slöseri med minnesutrymme genom att flytta båda elementen till vänster och justera fram- och bakänden därefter. Det är inte ett praktiskt bra tillvägagångssätt eftersom att flytta alla element kommer att ta mycket tid. Den effektiva metoden för att undvika slöseri med minnet är att använda den cirkulära ködatastrukturen.

Vad är en cirkulär kö?

En cirkulär kö liknar en linjär kö då den också är baserad på FIFO-principen (First In First Out) förutom att den sista positionen är kopplad till den första positionen i en cirkulär kö som bildar en cirkel. Det är också känt som en Ringbuffert .

Operationer på cirkulär kö

Följande är operationerna som kan utföras på en cirkulär kö:

Främre:Den används för att hämta frontelementet från kön.Bak:Den används för att hämta det bakre elementet från kön.enQueue(värde):Denna funktion används för att infoga det nya värdet i kön. Det nya elementet sätts alltid in från baksidan.deQueue():Denna funktion tar bort ett element från kön. Raderingen i en kö sker alltid från fronten.

Tillämpningar av Circular Queue

Den cirkulära kön kan användas i följande scenarier:

Minneshantering:Den cirkulära kön ger minneshantering. Som vi redan har sett att i linjär kö hanteras minnet inte särskilt effektivt. Men vid en cirkulär kö hanteras minnet effektivt genom att elementen placeras på en plats som är oanvänd.CPU-schemaläggning:Operativsystemet använder också den cirkulära kön för att infoga processerna och sedan exekvera dem.Trafiksystem:I ett datorstyrt trafiksystem är trafikljus ett av de bästa exemplen på cirkulär kö. Varje trafikljus tänds ett efter ett efter varje tidsintervall. Som att rött ljus lyser i en minut sedan gult ljus i en minut och sedan grönt ljus. Efter grönt ljus tänds det röda ljuset.

Ködrift

Stegen för ködrift ges nedan:

sträng till json java

vad är desktop ini

• Först kontrollerar vi om kön är tom eller inte. Om kön är tom kan vi inte utföra avköningsoperationen.
• När elementet raderas, minskas värdet på front med 1.
• Om det bara finns ett element kvar som ska raderas, så återställs den främre och bakre delen till -1.

Algoritm för att ta bort ett element från den cirkulära kön

Steg 1: OM FRONT = -1
Skriv 'UNDERFLÖDE'
Gå till steg 4
[END of IF]

Steg 2: SET VALUE = KÖ[FRONT]

Steg 3: OM FRAM = BAK
STÄLL IN FRAM = BAK = -1
ANNAN
OM FRONT = MAX -1
SET FRONT = 0
ANNAN
SET FRONT = FRONT + 1
[END of IF]
[SLUT PÅ OM]

Steg 4: UTGÅNG

Låt oss förstå enqueue och dequeue operationen genom den schematiska representationen.

Implementering av cirkulär kö med Array

 #include # define max 6 int queue[max]; // array declaration int front=-1; int rear=-1; // function to insert an element in a circular queue void enqueue(int element) { if(front==-1 && rear==-1) // condition to check queue is empty { front=0; rear=0; queue[rear]=element; } else if((rear+1)%max==front) // condition to check queue is full { printf('Queue is overflow..'); } else { rear=(rear+1)%max; // rear is incremented queue[rear]=element; // assigning a value to the queue at the rear position. } } // function to delete the element from the queue int dequeue() { if((front==-1) && (rear==-1)) // condition to check queue is empty { printf('
Queue is underflow..'); } else if(front==rear) { printf('
The dequeued element is %d', queue[front]); front=-1; rear=-1; } else { printf('
The dequeued element is %d', queue[front]); front=(front+1)%max; } } // function to display the elements of a queue void display() { int i=front; if(front==-1 && rear==-1) { printf('
 Queue is empty..'); } else { printf('
Elements in a Queue are :&apos;); while(i<=rear) { printf('%d,', queue[i]); i="(i+1)%max;" } int main() choice="1,x;" variables declaration while(choice<4 && choice!="0)" while loop printf('
 press 1: insert an element'); printf('
press 2: delete 3: display the printf('
enter your choice'); scanf('%d', &choice); switch(choice) case printf('enter element which is to be inserted'); &x); enqueue(x); break; dequeue(); display(); }} return 0; < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/ds-tutorial/14/circular-queue-10.webp" alt="Circular Queue"> <h3>Implementation of circular queue using linked list</h3> <p>As we know that linked list is a linear data structure that stores two parts, i.e., data part and the address part where address part contains the address of the next node. Here, linked list is used to implement the circular queue; therefore, the linked list follows the properties of the Queue. When we are implementing the circular queue using linked list then both the <strong> <em>enqueue and dequeue</em> </strong> operations take <strong> <em>O(1)</em> </strong> time.</p> <pre> #include // Declaration of struct type node struct node { int data; struct node *next; }; struct node *front=-1; struct node *rear=-1; // function to insert the element in the Queue void enqueue(int x) { struct node *newnode; // declaration of pointer of struct node type. newnode=(struct node *)malloc(sizeof(struct node)); // allocating the memory to the newnode newnode-&gt;data=x; newnode-&gt;next=0; if(rear==-1) // checking whether the Queue is empty or not. { front=rear=newnode; rear-&gt;next=front; } else { rear-&gt;next=newnode; rear=newnode; rear-&gt;next=front; } } // function to delete the element from the queue void dequeue() { struct node *temp; // declaration of pointer of node type temp=front; if((front==-1)&amp;&amp;(rear==-1)) // checking whether the queue is empty or not { printf(&apos;
Queue is empty&apos;); } else if(front==rear) // checking whether the single element is left in the queue { front=rear=-1; free(temp); } else { front=front-&gt;next; rear-&gt;next=front; free(temp); } } // function to get the front of the queue int peek() { if((front==-1) &amp;&amp;(rear==-1)) { printf(&apos;
Queue is empty&apos;); } else { printf(&apos;
The front element is %d&apos;, front-&gt;data); } } // function to display all the elements of the queue void display() { struct node *temp; temp=front; printf(&apos;
 The elements in a Queue are : &apos;); if((front==-1) &amp;&amp; (rear==-1)) { printf(&apos;Queue is empty&apos;); } else { while(temp-&gt;next!=front) { printf(&apos;%d,&apos;, temp-&gt;data); temp=temp-&gt;next; } printf(&apos;%d&apos;, temp-&gt;data); } } void main() { enqueue(34); enqueue(10); enqueue(23); display(); dequeue(); peek(); } </pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/ds-tutorial/14/circular-queue-11.webp" alt="Circular Queue"> <hr></=rear)>

Produktion:

rädda från