{"id":62702,"date":"2019-07-12T17:04:08","date_gmt":"2019-07-12T11:34:08","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=62702"},"modified":"2021-07-23T10:24:03","modified_gmt":"2021-07-23T04:54:03","slug":"queue-in-c-cpp","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/queue-in-c-cpp\/","title":{"rendered":"Queue in C\\C++ (FIFO) – How Queues are Implemented with Arrays & Linked List"},"content":{"rendered":"

After learning the concept of Stacks (LIFO), it’s time to discuss Queue in C\/C++. The concept of Queue follows the FIFO rule, which means First in First Out. Don’t get confused between Stacks and Queues in C and C++. Here, we will clear all your doubts with examples.<\/p>\n

In this article, we will cover the implementation of queues with array and linked list and circular queue in C\/C++ with syntax and examples.<\/p>\n

So, what are you waiting for? Let’s dive in.<\/p>\n

1. What is a Queue in C\/C++?<\/h2>\n

In contrast to a stack, a queue is nothing but a linear data structure that follows the FIFO<\/strong> rule (First In First Out<\/em>). Insertion is done from the back (the rear end) and deletion is done from the front. In order to better understand the concept of queues in C, we can say that it follows the rule of \u201cFirst Come First Serve\u201d. Let us consider a simple scenario to help you get a clear picture of queues.<\/p>\n

Learn More about Structures in C Language<\/a><\/strong><\/em><\/p>\n

Suppose you want to purchase a movie ticket. For that, you need to stand in a queue and wait for your turn, that is, you have to stand at the rear end of the queue. You can\u2019t simply stand in the middle of the queue or occupy the front position.<\/p>\n

From the above discussion, it is pretty obvious that insertion in a queue takes place from the back and deletion takes place from the front as the first person to enter the queue would be the first to get his job done and leave.<\/p>\n

\"C<\/a><\/p>\n

We can implement a queue in 2 ways:<\/strong><\/p>\n

    \n
  1. Statically:<\/strong> Array implementation of queues allows the static memory allocation of its data elements. It is important to note that in this method, the queue acquires all the features of an array.<\/li>\n
  2. Dynamically:<\/strong> Linked list implementation of queues follow the dynamic memory allocation of its data elements. It is important to note that in this method, the queue inherits all the characteristics of a linked list.<\/li>\n<\/ol>\n

    Key takeaway:<\/strong> Both stacks and queues can be static or dynamic according to the way they are implemented.<\/p>\n

    It’s the right time to uncover the secrete of \u00a0Arrays in C and C++<\/a><\/strong><\/em><\/p>\n

    2. Array Implementation of Queue in C\/C++<\/h2>\n

    As we already discussed, arrays support the static memory allocation of the data elements of the queue. Therefore, it is important to determine the size of the queue prior to the program run.<\/p>\n

    The queue functions basically include:<\/strong><\/p>\n

    2.1 Insertion<\/h4>\n

    Insertion of elements into the queue takes place from the rear end and hence would force the elements to shift forward. Inserting an element into the queue is also called enqueue.<\/p>\n

    Here is a diagrammatic representation of how elements are inserted into a queue:<\/strong><\/p>\n

    \"Insertion<\/a><\/p>\n

    Insert elements into a queue in C<\/h5>\n
    void insert()\r\n{\r\nint element;\r\nif (rear == LIMIT - 1)\r\nprintf(\"Queue Overflow\\n\");\r\nelse\r\n{\r\nif (front == - 1)\r\nfront = 0;\r\nprintf(\"Enter the element to be inserted in the queue: \");\r\nscanf(\"%d\", &element);\r\nrear++;\r\nqueue[rear] = element;\r\n}\r\n}<\/pre>\n
    Insert elements into a queue in C++<\/h5>\n
    void insert()\r\n{\r\nint element;\r\nif (rear == LIMIT - 1)\r\ncout<<\"Queue Overflow\\n\";\r\nelse\r\n{\r\nif (front == - 1)\r\nfront = 0;\r\ncout<<\"Enter the element to be inserted in the queue: \";\r\ncin>>element;\r\nrear++;\r\nqueue[rear] = element;\r\n}\r\n}<\/pre>\n
    Unveil the Important Concepts of Multi-dimensional Arrays in C\/C++ (2D & 3D Arrays)<\/a><\/strong><\/em><\/p>\n
    2.2 Deletion<\/h4>\n
    In a queue, the deletion of data elements is done from the front. Deleting the element from the queue is also called dequeue.<\/p>\n
    Here is a diagrammatic representation of how elements are deleted from a queue:<\/strong><\/p>\n
    \"Deletion<\/a><\/p>\n
    Delete elements from the queue in C<\/h5>\n
    void delet()\r\n{\r\nif (front == - 1 || front > rear)\r\n{\r\nprintf(\"Queue Underflow \\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The deleted element in the queue is: %d\\n\", queue[front]);\r\nfront++;\r\n}\r\n}\r\n<\/pre>\n
    Delete elements from the queue in C++<\/h5>\n
    void delet()\r\n{\r\nif (front == - 1 || front > rear)\r\n{\r\ncout<<\"Queue Underflow \\n\";\r\n}\r\nelse\r\n{\r\ncout<<\"The deleted element in the queue is: \" << queue[front] <<endl;\r\nfront++;\r\n}\r\n}<\/pre>\n
    Key takeaway:<\/strong> It is important to note that we used the function name \u201cdelet\u201d instead of \u201cdelete\u201d because \u201cdelete\u201d is a keyword.<\/p>\n
    2.3 Display<\/h4>\n
    The stack data elements are displayed in the queue according to the FIFO rule.<\/p>\n
    Display all the elements in the queue in C<\/h5>\n
    void display()\r\n{\r\nint i;\r\nif (front == - 1)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The elements of the queue are:\\n\");\r\nfor (i = front; i <= rear; i++)\r\nprintf(\"%d\\n\", queue[i]);\r\n}\r\n}<\/pre>\n
    Display all the elements in the queue in C++<\/h5>\n
    void display()\r\n{\r\nint i;\r\nif (front == - 1)\r\n{\r\ncout<<\"Queue underflow\\n\";\r\n}\r\nelse\r\n{\r\ncout<<\"The elements of the queue are:\\n\";\r\nfor (i = front; i <= rear; i++)\r\ncout<<queue[i];\r\n}\r\n}<\/pre>\n
    Similarly, in queues, apart from these 3 main functions, it is necessary to check the overflow and underflow conditions to avoid unfavorable situations.<\/p>\n
    Example of Array Implementation of Queues in C<\/h3>\n
    #include <stdio.h>\r\n#include <stdlib.h>\r\n#define LIMIT 100 \/\/ Specifying the maximum limit of the queue\r\n\r\n\/* Global declaration of variables *\/\r\n\r\nint queue[LIMIT]; \/\/ Array implementation of queue\r\nint front, rear; \/\/ To insert and delete the data elements in the queue respectively\r\nint i; \/\/ To traverse the loop to while displaying the stack\r\nint choice; \/\/ To choose either of the 3 stack operations\r\n\r\nvoid insert(); \/\/ Function used to insert the element into the queue\r\nvoid delet(); \/\/ Function used to delete the elememt from the queue\r\nvoid display(); \/\/ Function used to display all the elements in the queue according to FIFO rule\r\n\r\nint main()\r\n{\r\n\r\nprintf(\"Welcome to DataFlair tutorials!\\n\\n\");\r\n\r\nprintf (\"ARRAY IMPLEMENTATION OF QUEUES\\n\\n\");\r\nfront = rear = -1; \/\/ Initialzing front and rear to -1 indicates that it is empty\r\ndo\r\n{\r\n\r\nprintf(\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\");\r\nprintf(\"Enter your choice:\");\r\nscanf(\"%d\",&choice);\r\n\r\nswitch(choice)\r\n{\r\ncase 1:\r\ninsert();\r\nbreak;\r\ncase 2:\r\ndelet();\r\nbreak;\r\ncase 3:\r\ndisplay();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\nprintf(\"Sorry, invalid choice!\\n\");\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0;\r\n}\r\n\r\nvoid insert()\r\n{\r\nint element;\r\nif (rear == LIMIT - 1)\r\nprintf(\"Queue Overflow\\n\");\r\nelse\r\n{\r\nif (front == - 1)\r\nfront = 0;\r\nprintf(\"Enter the element to be inserted in the queue: \");\r\nscanf(\"%d\", &element);\r\nrear++;\r\nqueue[rear] = element;\r\n}\r\n}\r\n\r\nvoid delet()\r\n{\r\nif (front == - 1 || front > rear)\r\n{\r\nprintf(\"Queue Underflow \\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The deleted element in the queue is: %d\\n\", queue[front]);\r\nfront++;\r\n}\r\n}\r\n\r\nvoid display()\r\n{\r\nint i;\r\nif (front == - 1)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The elements of the queue are:\\n\");\r\nfor (i = front; i <= rear; i++)\r\nprintf(\"%d\\n\", queue[i]);\r\n}\r\n}\r\n<\/pre>\n
    Output-<\/strong><\/p>\n
    \"array<\/a><\/p>\n
    \"Output<\/a><\/h3>\n
    \"array<\/a><\/h3>\n
    Example of Array Implementation of Queues in C++<\/h3>\n
    #include <iostream>\r\n#include <stdlib.h> \r\n#define LIMIT 100 \/\/ Specifying the maximum limit of the queue\r\nusing namespace std;\r\n \r\n\/* Global declaration of variables *\/\r\n\r\nint queue[LIMIT]; \/\/ Array implementation of queue\r\nint front, rear; \/\/ To insert and delete the data elements in the queue respectively\r\nint i; \/\/ To traverse the loop to while displaying the stack\r\nint choice; \/\/ To choose either of the 3 stack operations\r\n\r\nvoid insert(); \/\/ Function used to insert an element into the queue\r\nvoid delet(); \/\/ Function used to delete an element from the queue\r\nvoid display(); \/\/ Function used to display all the elements in the queue according to FIFO rule\r\n \r\nint main()\r\n{\r\n\r\ncout<<\"Welcome to DataFlair tutorials!\"<<endl<<endl;\r\n\r\ncout<< \"ARRAY IMPLEMENTATION OF QUEUES \"<<endl<<endl;;\r\nfront = rear = -1; \/\/ Initializing front and rear to -1 indicates that it is empty\r\ndo\r\n{\r\n                                                                                                                                                                                                         \r\ncout<<\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\";\r\ncout<<\"Enter your choice: \";\r\ncin>>choice;\r\n \r\nswitch(choice)\r\n{\r\ncase 1:\r\ninsert();\r\nbreak;\r\ncase 2:\r\ndelet();\r\nbreak;\r\ncase 3:\r\ndisplay();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\nprintf(\"Sorry, invalid choice!\\n\");\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0; \r\n}\r\n\r\nvoid insert()\r\n{\r\nint element;\r\nif (rear == LIMIT - 1)\r\ncout<<\"Queue Overflow\\n\";\r\nelse\r\n{\r\nif (front == - 1)\r\nfront = 0;\r\ncout<<\"Enter the element to be inserted in the queue: \";\r\ncin>>element;\r\nrear++;\r\nqueue[rear] = element;\r\n}\r\n} \r\n\r\nvoid delet()\r\n{\r\nif (front == - 1 || front > rear)\r\n{\r\ncout<<\"Queue Underflow \\n\";\r\n}\r\nelse\r\n{\r\ncout<<\"The deleted element in the queue is: \"<< queue[front]<<endl;\r\nfront++;\r\n}\r\n} \r\n\r\nvoid display()\r\n{\r\nint i;\r\nif (front == - 1)\r\n{\r\ncout<<\"Queue underflow\\n\";\r\n}\r\nelse\r\n{\r\ncout<<\"The elements of the queue are:\\n\"<<endl;\r\nfor (i = front; i <= rear; i++)\r\ncout<< queue[i] <<endl;\r\n}\r\n}<\/pre>\n
    Output-<\/strong><\/p>\n
    \"Example<\/a><\/p>\n
    \"Array<\/a><\/p>\n
    Do you know how the Linked list works in C and C++?<\/a><\/strong><\/em><\/p>\n
    3. Linked List Implementation of Queue in C\/C++<\/h2>\n
    As we already discussed, linked lists support the dynamic memory allocation of the data elements of the queue. Therefore, the size of the queue is allocated during the program run and needn\u2019t be specified beforehand.<\/p>\n
    The 3 basic operations of Insertion, Deletion, and Display follow a similar trend as we saw in the array implementation of queues.<\/p>\n
    It is important to note that the condition of queue overflow does not exist in the linked list implementation of queues and the size of the stack is not pre-determined. But, the queue underflow condition still holds true.<\/p>\n
    3.1 Insertion<\/h4>\n
    Insert elements into the queue in C<\/h5>\n
    void insert()\r\n{\r\nstruct node *temp;\r\n\r\ntemp = (struct node*)malloc(sizeof(struct node));\r\nprintf(\"Enter the element to be inserted in the queue: \");\r\nscanf(\"%d\", &temp->data);\r\ntemp->link = NULL;\r\nif (rear == NULL)\r\n{\r\nfront = rear = temp;\r\n}\r\nelse\r\n{\r\nrear->link = temp;\r\nrear = temp;\r\n}\r\n}\r\n<\/pre>\n
    Insert elements into the queue in C++<\/h5>\n
    (Here we have used classes to implement linked lists)<\/p>\n
    \/\/ Structure definition\r\nstruct node\r\n{\r\nint data;\r\nnode *next;\r\n};\r\n\/\/ Class definition\r\nclass Queue\r\n{\r\nnode *rear,*front;\r\npublic:\r\nQueue()\r\n{\r\nrear = NULL;\r\nfront = NULL;\r\n}\r\nvoid insert();\r\n};\r\n\/\/ Member function definition\r\nvoid Queue :: insert()\r\n{\r\nnode *temp;\r\ntemp = new node;\r\ncout<<\"Enter the element to be inserted: \";\r\ncin>> temp -> data;\r\ntemp -> next = NULL;\r\nif(rear == NULL)\r\n{\r\nrear = temp;\r\nfront=temp;\r\n}\r\nelse\r\n{\r\nrear -> next = temp;\r\nrear = temp;\r\n}\r\n}<\/pre>\n
    3.2 Deletion<\/h4>\n
    Delete elements in a queue in C<\/h5>\n
    void delet()\r\n{\r\nstruct node *temp;\r\ntemp = front;\r\nif (front == NULL)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\nfront = rear = NULL;\r\n}\r\nelse\r\n{\r\nprintf(\"The deleted element from the queue is: %d\\n\", front->data);\r\nfront = front->link;\r\nfree(temp);\r\n}\r\n}<\/pre>\n
    Delete elements in a queue in C++<\/h5>\n
    \/\/ Structure definition\r\nstruct node\r\n{\r\nint data;\r\nnode *next;\r\n};\r\n\/\/ Class definition\r\nclass Queue\r\n{\r\nnode *rear,*front;\r\npublic:\r\nQueue()\r\n{\r\nrear = NULL;\r\nfront = NULL;\r\n}\r\nvoid delet();\r\n};\r\n\/\/ Member function definition\r\nvoid Queue :: delet()\r\n{\r\nif(front != NULL)\r\n{\r\nnode *temp = front;\r\ncout<< \u201cThe deleted element is: \u201d <<front -> data <<endl;\r\nfront = front -> next;\r\ndelete temp;\r\nif(front == NULL)\r\nrear = NULL;\r\n}\r\nelse\r\ncout<<\"Queue Underflow!.\";\r\n}<\/pre>\n
    3.3 Display<\/h4>\n
    Display elements in the queue in C<\/h5>\n
    void display()\r\n{\r\nstruct node *temp;\r\ntemp = front;\r\nint cnt = 0;\r\nif (front == NULL)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The elements of the stack are:\\n\");\r\nwhile (temp)\r\n{\r\nprintf(\"%d\\n\", temp->data);\r\ntemp = temp->link;\r\ncnt++;\r\n}\r\n}\r\n}<\/pre>\n
    Display elements in the queue in C++<\/h5>\n
    \/\/ Structure definition\r\nstruct node\r\n{\r\nint data;\r\nnode *next;\r\n};\r\n\/\/ Class definition\r\nclass Queue\r\n{\r\nnode *rear,*front;\r\npublic:\r\nQueue()\r\n{\r\nrear = NULL;\r\nfront = NULL;\r\n}\r\nvoid display();\r\n};\r\n\/\/ Member function definition\r\nvoid Queue :: display()\r\n{\r\nnode *temp = front;\r\nwhile(temp != NULL)\r\n{\r\ncout<< temp -> data <<endl;\r\ntemp = temp -> next;\r\n}\r\n}<\/pre>\n
    Example of linked list implementation of queues in C<\/h3>\n
    #include <stdio.h>\r\n#include <stdlib.h>\r\n\r\nstruct node\r\n{\r\nint data;\r\nstruct node *link;\r\n}*front, *rear;\r\n\r\nvoid insert(); \/\/ Function used to insert the element into the queue\r\nvoid delet(); \/\/ Function used to delete the elememt from the queue\r\nvoid display(); \/\/ Function used to display all the elements in the queue according to FIFO rule\r\n\r\nint main()\r\n{\r\n\r\nprintf(\"Welcome to DataFlair tutorials!\\n\\n\");\r\n\r\nint choice;\r\nprintf (\"LINKED LIST IMPLEMENTATION OF QUEUES\\n\\n\");\r\ndo\r\n{\r\n\r\nprintf(\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\");\r\nprintf(\"Enter your choice:\");\r\nscanf(\"%d\",&choice);\r\n\r\nswitch(choice)\r\n{\r\ncase 1:\r\ninsert();\r\nbreak;\r\ncase 2:\r\ndelet();\r\nbreak;\r\ncase 3:\r\ndisplay();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\nprintf(\"Sorry, invalid choice!\\n\");\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0;\r\n}\r\n\r\nvoid insert()\r\n{\r\nstruct node *temp;\r\n\r\ntemp = (struct node*)malloc(sizeof(struct node));\r\nprintf(\"Enter the element to be inserted in the queue: \");\r\nscanf(\"%d\", &temp->data);\r\ntemp->link = NULL;\r\nif (rear == NULL)\r\n{\r\nfront = rear = temp;\r\n}\r\nelse\r\n{\r\nrear->link = temp;\r\nrear = temp;\r\n}\r\n}\r\n\r\nvoid delet()\r\n{\r\nstruct node *temp;\r\ntemp = front;\r\nif (front == NULL)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\nfront = rear = NULL;\r\n}\r\nelse\r\n{\r\nprintf(\"The deleted element from the queue is: %d\\n\", front->data);\r\nfront = front->link;\r\nfree(temp);\r\n}\r\n}\r\n\r\nvoid display()\r\n{\r\nstruct node *temp;\r\ntemp = front;\r\nint cnt = 0;\r\nif (front == NULL)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nelse\r\n{\r\nprintf(\"The elements of the stack are:\\n\");\r\nwhile (temp)\r\n{\r\nprintf(\"%d\\n\", temp->data);\r\ntemp = temp->link;\r\ncnt++;\r\n}\r\n}\r\n}<\/pre>\n
    Output-<\/strong><\/p>\n
    \"linked<\/a><\/p>\n
    \"Output<\/a><\/p>\n
    \"Linked<\/a><\/p>\n
    Example of linked list implementation of queues in C++<\/h3>\n
    #include <iostream>\r\nusing namespace std;\r\n\r\nstruct node\r\n{\r\nint data;\r\nnode *next;\r\n};\r\n\r\nclass Queue\r\n{\r\nnode *rear,*front;\r\npublic:\r\nQueue()\r\n{ \r\nrear = NULL;\r\nfront = NULL;\r\n}\r\nvoid insert(); \/\/ Function used to insert an element into the queue\r\nvoid delet(); \/\/ Function used to delete an element from the queue\r\nvoid display(); \/\/ Function used to display all the elements in the queue according to FIFO rule\r\n};\r\n\r\nvoid Queue :: insert()\r\n{\r\nnode *temp;\r\ntemp = new node;\r\ncout<<\"Enter the element to be inserted: \";\r\ncin>> temp -> data;\r\ntemp -> next = NULL;\r\nif(rear == NULL)\r\n{\r\nrear = temp;\r\nfront = temp;\r\n}\r\nelse\r\n{\r\nrear -> next = temp;\r\nrear = temp;\r\n}\r\n}\r\n\r\nvoid Queue :: delet()\r\n{\r\nif(front != NULL)\r\n{\r\nnode *temp = front;\r\ncout<< \"The deleted element is: \" << front -> data <<endl;\r\nfront = front -> next;\r\ndelete temp;\r\nif(front == NULL)\r\nrear= NULL;\r\n}\r\nelse\r\ncout<<\"Queue Underflow!\"<<endl;\r\n}\r\n\r\nvoid Queue :: display()\r\n{\r\nnode *temp=front;\r\nwhile(temp!=NULL)\r\n{\r\ncout<< temp -> data <<endl;\r\ntemp = temp -> next;\r\n}\r\n}\r\n\r\n\r\nint main()\r\n{\r\n\r\ncout<<\"Welcome to DataFlair tutorials!\"<<endl<<endl;\r\n\r\nQueue q;\r\nint choice;\r\ncout<<\"LINKED LIST IMPLEMENTATION OF QUEUES\\n\\n\";\r\ndo\r\n{\r\n\r\ncout<<\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\";\r\ncout<<\"Enter your choice:\";\r\ncin>>choice;\r\n\r\nswitch(choice)\r\n{\r\ncase 1:\r\nq.insert();\r\nbreak;\r\ncase 2:\r\nq.delet();\r\nbreak;\r\ncase 3:\r\nq.display();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\ncout<<\"Sorry, invalid choice!\\n\";\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0;\r\n}<\/pre>\n
    Output-<\/strong><\/p>\n
    \"linked<\/a><\/p>\n
    \"Output<\/a><\/p>\n
    4. Circular Queue in C\/C++<\/h2>\n
    The role of a circular queue comes into play when we wish to avoid the loss of computer memory using arrays. It is based on the principle that the rear end of the queue becomes equal to its front end.<\/p>\n
    Here is a diagrammatic representation of how a circular queue looks like:<\/strong><\/p>\n
    \"Circular<\/a><\/p>\n
    The circular queue operations are the same as that of a linear queue<\/em>, that is, insertion, deletion and display and checking of boundary conditions such as overflow and underflow.<\/p>\n
    We have discussed the 3 basic operations in detail:<\/p>\n
    4.1 Insertion<\/h4>\n
    Insert elements in the circular queue in C<\/h5>\n
    void insert()\r\n{\r\nif((front == 0 && rear == LIMIT-1) || (front == rear+1))\r\n{\r\nprintf(\"Queue Overflow\\n\");\r\n}\r\nif (front == -1) \/\/If queue is empty\r\n{\r\nfront = rear = 0;\r\n}\r\nelse\r\n{\r\nprintf(\"Enter the element to be inserted in queue: \");\r\nscanf(\"%d\", &item);\r\nif(rear == LIMIT-1) \/\/ When rear is at the last position of the queue\r\n{\r\nrear = 0;\r\n}\r\nelse\r\n{\r\nrear++;\r\n}\r\n}\r\ncqueue[rear] = item ;\r\n}<\/pre>\n
    Insert elements in the circular queue in C++<\/h5>\n
    void insert()\r\n{\r\nif((front == 0 && rear == LIMIT-1) || (front == rear+1))\r\n{\r\ncout<<\"Queue Overflow\\n\";\r\n}\r\nif (front == -1)  \/\/ If the queue is empty \r\n{\r\nfront = rear = 0;\r\n}\r\nelse\r\n{\r\n\r\ncout<<\"Enter the element to be inserted in queue: \";\r\ncin>>item);\r\nif(rear == LIMIT-1) \/\/ When rear is at the last position of the queue \r\n{\r\nrear = 0;\r\n}\r\nelse\r\n{\r\nrear++;\r\n}\r\n}\r\ncqueue[rear] = item ;\r\n}<\/pre>\n
    4.2 Delete<\/h4>\n
    Delete elements in a circular queue in C<\/h5>\n
    void delet()\r\n{\r\nif (front == -1)\r\n{\r\nprintf(\"Queue Underflow\\n\");\r\n}\r\nprintf(\"Element deleted from queue is : %d\\n\",cqueue[front]);\r\nif(front == rear) \/* queue has only one element *\/\r\n{\r\nfront = rear = -1;\r\n}\r\nelse\r\n{\r\nif(front == LIMIT-1)\r\n{\r\nfront = 0;\r\n}\r\nelse\r\nfront++;\r\n}\r\n}<\/pre>\n
    Delete elements in a circular queue in C++<\/h5>\n
    void delet()\r\n{\r\nif (front == -1)\r\n{\r\ncout<<\"Queue Underflow\\n\";\r\n}\r\ncout<<\"Element deleted from queue is: \"<< cqueue[front] << endl;\r\nif(front == rear) \/* queue has only one element *\/\r\n{\r\nfront = rear = -1;\r\n}\r\nelse\r\n{\t\r\nif(front == LIMIT-1)\r\n{\r\nfront = 0;\r\n}\r\nelse\r\nfront++;\r\n}\r\n}<\/pre>\n
    4.3 Display<\/h4>\n
    Display elements in the circular queue in C<\/h5>\n
    void display()\r\n{\r\nint front_position = front;\r\nint rear_position = rear;\r\nif(front == -1)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nprintf(\"The elements of the queue are:\\n\");\r\nif( front_position <= rear_position )\r\nwhile(front_position <= rear_position)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\nelse\r\n{\r\nwhile(front_position <= LIMIT-1)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\nfront_position = 0;\r\nwhile(front_position <= rear_position)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\n}\r\n}<\/pre>\n
    Display elements in the circular queue in C++<\/h5>\n
    void display()\r\n{\r\nint front_position = front;\r\nint rear_position = rear;\r\nif(front == -1)\r\n{\r\ncout<<\"Queue underflow\\n\";\r\n}\r\ncout<<\"The elements of the queue are:\\n\";\r\nif( front_position <= rear_position )\r\nwhile(front_position <= rear_position)\r\n{\r\ncout<<cqueue[front_position]<<endl;\r\nfront_position++;\r\n}\r\nelse\r\n{\r\nwhile(front_position <= LIMIT-1)\r\n{\r\ncout<<cqueue[front_position];\r\nfront_position++;\r\n}\r\nfront_position = 0;\r\nwhile(front_position <= rear_position)\r\n{\r\ncout<<cqueue[front_position]<<endl;\r\nfront_position++;\r\n}\r\n}\r\n}<\/pre>\n
    The example of implementation of a circular queue in C<\/h3>\n
    #include<stdio.h>\r\n#include<stdlib.h>\r\n#define LIMIT 10\r\n\r\n\/* Global declaration of variables *\/\r\nint cqueue[LIMIT];\r\nint choice, item;\r\nint front, rear; \r\n\r\nvoid insert(); \/\/ Function to insert the element in the queue\r\nvoid delet(); \/\/ Function to delete the element in the queue\r\nvoid display(); \/\/ Function to display the element in the queue\r\n\r\nint main()\r\n{\r\n\r\nprintf(\"Welcome to DataFlair tutorials!\\n\\n\");\r\n\r\nprintf (\"ARRAY IMPLEMENTATION OF QUEUES\\n\\n\");\r\n\r\nfront = rear = -1; \/\/ It indicates the queue is empty\r\ndo\r\n{\r\n\r\nprintf(\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\");\r\nprintf(\"Enter your choice:\");\r\nscanf(\"%d\",&choice);\r\n\r\nswitch(choice)\r\n{\r\ncase 1:\r\ninsert();\r\nbreak;\r\ncase 2:\r\ndelet();\r\nbreak;\r\ncase 3:\r\ndisplay();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\nprintf(\"Sorry, invalid choice!\\n\");\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0;\r\n}\r\n\r\nvoid insert()\r\n{\r\nif((front == 0 && rear == LIMIT-1) || (front == rear+1))\r\n{\r\nprintf(\"Queue Overflow\\n\");\r\n}\r\nif (front == -1)  \/\/If the queue is empty \r\n{\r\nfront = rear = 0;\r\n}\r\nelse\r\n{\r\nprintf(\"Enter the element to be inserted in queue: \");\r\nscanf(\"%d\", &item);\r\nif(rear == LIMIT-1) \/\/ When rear is at the last position of the queue \r\n{\r\nrear = 0;\r\n}\r\nelse\r\n{\r\nrear++;\r\n}\r\n}\r\ncqueue[rear] = item ;\r\n}\r\n\r\nvoid delet()\r\n{\r\nif (front == -1)\r\n{\r\nprintf(\"Queue Underflow\\n\");\r\n}\r\nif(front!= -1)\r\nprintf(\"Element deleted from queue is : %d\\n\",cqueue[front]);\r\nif(front == rear) \/* queue has only one element *\/\r\n{\r\nfront = rear = -1;\r\n}\r\nelse\r\n{\t\r\nif(front == LIMIT-1)\r\n{\r\nfront = 0;\r\n}\r\nelse\r\nfront++;\r\n}\r\n}\r\n\r\nvoid display()\r\n{\r\nint front_position = front;\r\nint rear_position = rear;\r\nif(front == -1)\r\n{\r\nprintf(\"Queue underflow\\n\");\r\n}\r\nif(front!= -1)\r\nprintf(\"The elements of the queue are:\\n\");\r\nif( front_position <= rear_position )\r\nwhile(front_position <= rear_position)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\nelse\r\n{\r\nwhile(front_position <= LIMIT-1)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\nfront_position = 0;\r\nwhile(front_position <= rear_position)\r\n{\r\nprintf(\"%d\\n\",cqueue[front_position]);\r\nfront_position++;\r\n}\r\n}\r\n}<\/pre>\n
    Output-<\/strong><\/p>\n
    \"<\/a><\/p>\n
    \"<\/a><\/h3>\n
    \"Result<\/a><\/h3>\n
    The example of implementation of a circular queue in C++<\/h3>\n
    #include <iostream>\r\n#include <stdlib.h>\r\n#define LIMIT 10\r\nusing namespace std;\r\n\r\n\/* Global declaration of variables *\/\r\nint cqueue[LIMIT];\r\nint choice, item;\r\nint front, rear; \r\n\r\nvoid insert(); \/\/ Function to insert the element in the queue\r\nvoid delet(); \/\/ Function to delete the element in the queue\r\nvoid display(); \/\/ Function to display the element in the queue\r\n\r\nint main()\r\n{\r\n\r\ncout<<\"Welcome to DataFlair tutorials!\"<<endl<<endl;\r\n\r\ncout<<\"ARRAY IMPLEMENTATION OF QUEUES\\n\\n\";\r\n\r\nfront = rear = -1; \/\/ It indicates the queue is empty\r\ndo\r\n{\r\n\r\ncout<<\"1. Insert\\n2. Delete\\n3. Display\\n4. Exit\\n\\n\";\r\ncout<<\"Enter your choice:\";\r\ncin>>choice;\r\n\r\nswitch(choice)\r\n{\r\ncase 1:\r\ninsert();\r\nbreak;\r\ncase 2:\r\ndelet();\r\nbreak;\r\ncase 3:\r\ndisplay();\r\nbreak;\r\ncase 4:\r\nexit(0);\r\nbreak;\r\ndefault:\r\ncout<<\"Sorry, invalid choice!\\n\";\r\nbreak;\r\n}\r\n} while(choice!=4);\r\nreturn 0;\r\n}\r\n\r\nvoid insert()\r\n{\r\nif((front == 0 && rear == LIMIT-1) || (front == rear+1))\r\n{\r\ncout<<\"Queue Overflow\\n\";\r\n}\r\nif (front == -1)  \/\/If the queue is empty \r\n{\r\nfront = rear = 0;\r\n}\r\nelse\r\n{\r\ncout<<\"Enter the element to be inserted in queue: \";\r\ncin>>item;\r\nif(rear == LIMIT-1) \/\/ When rear is at the last position of the queue \r\n{\r\nrear = 0;\r\n}\r\nelse\r\n{\r\nrear++;\r\n}\r\n}\r\ncqueue[rear] = item ;\r\n}\r\n\r\nvoid delet()\r\n{\r\nif (front == -1)\r\n{\r\ncout<<\"Queue Underflow\\n\";\r\n}\r\nif(front!= -1)\r\ncout<<\"Element deleted from queue is :\"<< cqueue[front] <<endl;\r\nif(front == rear) \/* queue has only one element *\/\r\n{\r\nfront = rear = -1;\r\n}\r\nelse\r\n{\t\r\nif(front == LIMIT-1)\r\n{\r\nfront = 0;\r\n}\r\nelse\r\nfront++;\r\n}\r\n}\r\n\r\nvoid display()\r\n{\r\nint front_position = front;\r\nint rear_position = rear;\r\nif(front == -1)\r\n{\r\ncout<<\"Queue underflow\\n\";\r\n}\r\nif(front!= -1)\r\ncout<<\"The elements of the queue are: \"<<endl;\r\nif( front_position <= rear_position )\r\nwhile(front_position <= rear_position)\r\n{\r\ncout<<cqueue[front_position]<<endl;\r\nfront_position++;\r\n}\r\nelse\r\n{\r\nwhile(front_position <= LIMIT-1)\r\n{\r\ncout<<cqueue[front_position];\r\nfront_position++;\r\n}\r\nfront_position = 0;\r\nwhile(front_position <= rear_position)\r\n{\r\ncout<<cqueue[front_position];\r\nfront_position++;\r\n}\r\n}\r\n}<\/pre>\n
    Output-<\/strong><\/p>\n
    \"implementation<\/a><\/p>\n
    \"Output<\/a><\/p>\n
    \"Result<\/a><\/p>\n
    5. Applications of Queue in C\/C++<\/h2>\n
    The principle FIFO followed by queues gives birth to the various applications of queues. Some of the most popular applications of queues are:<\/p>\n