Queue oop

Nov 25, 2012Download as pptx, pdf2 likes2,105 views

The document discusses queues and their implementation. It defines a queue as a FIFO data structure where new items are added to the rear and removed from the front. Key queue operations are described like add, remove, isEmpty and isFull. The document then provides examples of implementing a queue using arrays and pointers in C++. It includes functions for initialization, insertion, removal, checking if empty, and printing all elements.

Queue

Prepared by:
Eng. Ahmed & Mohamed Taha

Agenda

 Introduction to Queue.

 How Queue works.

 Operations performed on Queue.

 Queue Implementation.

Introduction to Queue

 Queue is an ordered collection of items in which new data
items are added at the end, or tail, of the queue while
other data are removed from the front, or head, of the
queue. For this reason, a queue is referred to as a FIFO
structure (First-In First-Out)

 The main primitive operations of a queue are known as:

 Add adds a new node
 Remove removes a node

 Additional primitives can be defined:

 IsEmpty: reports whether the queue is empty
 IsFull: reports whether the queue is full
 Initialize: creates/initializes the queue
 Destroy: deletes the contents of the queue (may be
implemented by re-initializing the queue)

Queue Implementation
using Object Oriented
Programming

$Queue Implementation using Array #include <iostream.h> #include <conio.h> #include <stdlib.h> #define max_size 100 #define TRUE 1 #define FALSE 0 typedef int boolean; /************************************/ Class queue { private: int items[max_size]; int front,rear; public: };$

$Queue Implementation using address /////////////////////////////funcions // Initialize Function void queue:: queue() { front=0; rear=-1; } // Is_empty Function boolean queue:: is_empty() { if (rear < front) return TRUE; return FALSE; }$

$Queue Implementation using address // Insert Function void queue:: insert(int item) { if (rear == max_size-1) { cout<<"Queue is Overflow"; exit(0); } else rear++; items[rear]=item; }$

$Queue Implementation using address // Remove Function int queue:: remove() { if (is_empty()) { cout<<"Queue is underflow"; return -1; } int item=items[front]; front++; return item; }$

$Queue Implementation using address // Print all elements Funcion void queue:: print_all_elements () { cout<<"the current items of the queue are:"<<endl; for(int i=front;i<=rear;i++) cout<<items[i]<<" "; cout<<endl; }$

$Queue Implementation using address void main() { clrscr(); queue q; q.insert(1); q.insert(2); q.insert(3); q.insert(4); q.print_all_elements(q); int val=q.remove(); val=q.remove(); q.print_all_elements(); q.insert(5); q.insert(6); q.print_all_elements(); getch(); }$

This document describes two implementations of a queue data structure in C++. A queue uses the First In First Out (FIFO) principle to add and remove elements. Elements can be added to the rear of the queue using the Enque operation and removed from the front using the Deque operation. The first implementation uses an array to store queue elements, while the second uses linked nodes to dynamically allocate memory for elements as they are added. Both implementations provide functions for Enqueuing, Dequeuing, checking if the queue is empty, and displaying the queue elements.

Queue implementationRajendran

The document discusses queues, which implement the FIFO (first-in, first-out) policy. It describes the queue ADT interface with functions like enqueue(), dequeue(), and getFront(). It provides examples of using a queue and implementing queues using linked lists or arrays. Circular arrays are described as another implementation where the front and back pointers wrap around the end of the array. Checks for empty and full states are also covered.

A "Do-It-Yourself" Specification Language with BeepBeep 3 (Talk @ Dagstuhl 2017)Sylvain Hallé

BeepBeep 3: A declarative event stream query engine (EDOC 2015)Sylvain Hallé

We describe work in progress on the design and implementation of an SQL-like language for performing complex queries on event streams. This language aims at providing a simple, intuitive and fully non-procedural syntax, while still preserving backwards compatibility with traditional SQL. The syntax and informal semantics of the language are introduced; multiple examples of scenarios taken from past literature are then presented, and used to compare the expressiveness and intuitiveness of the proposed language with respect to existing Complex Event Processing engines.

When RV Meets CEP (RV 2016 Tutorial)Sylvain Hallé

This presentation is an introduction to Complex Event Processing (CEP) intended for an practicioners of Runtime Verification. It first describes typical CEP problems, popular tools and their query languages. It then presents BeepBeep 3, an event stream processor that attempts to bridge the gap between RV and CEP. Thanks to BeepBeep’s generic architecture and flexible input language, queries and properties from both fields can be efficiently processed.

Python 如何執行kao kuo-tung

The document discusses how Python code is executed. It explains that Python code is first compiled into code objects then executed via a frame object on the stack. Code objects contain details like function names and constants while frame objects contain details like the current code, local and global variables. It also describes the main components involved in execution like opcodes, bytecodes, and the CPython interpreter which evaluates bytecodes by calling corresponding operations.

Mca 2nd sem u-4 operator overloadingRai University

This document discusses operator overloading in C++. It defines operator overloading as polymorphism that gives user-defined meaning to operators when used with custom data types. Almost any operator can be overloaded except a few like :: and sizeof. Overloaded operators can be implemented as member functions, non-member functions, or friend functions. There are also rules for operator overloading, such as preserving precedence and arity of operators and requiring certain operators like [] and -> to be member functions. The document provides examples of overloading unary and binary operators as member and friend functions.

Activity Recognition Through Complex Event Processing: First Findings Sylvain Hallé

The activities of daily living of a patient in a smart home environment can be detected to a large extent by the real-time analysis of characteristics of the habitat's electrical consumption. However, reasoning over the conduct of these activities occurs at a much higher level of abstraction than what the sensors generally produce. In this paper, we leverage the concept of Complex Event Processing (CEP), in which low-level data streams are progressively transformed into higher-level ones, to the task of activity recognition. We show how the use of an appropriate representation for each level of abstraction can greatly simplify the process. We also report on the use of an existing event stream processor to successfully implement the complete chain, from low-level sensor data up to a sequence of discrete and high-level actions.

Functionvenkatme83

Data Structures - Lecture 6 [queues]Muhammad Hammad Waseem

The document discusses queues, which are a data structure that provides first-in, first-out (FIFO) access to elements. Queues are useful for applications like print jobs and network communications where elements need to be processed in the order they are received. The key queue operations are enqueue, which inserts an element at the rear, and dequeue, which removes an element from the front. The document provides code for an IntQueue class that implements these operations using a circular array to represent the queue.

The Big ThreeRoman Okolovich

Lecture05elearning_portal

This document discusses overloaded functions, inline functions, and default arguments in C++. It provides examples of each: 1) Overloaded functions allow different implementations of the same function name based on argument types. Inline functions avoid function call overhead by inserting the function code at the call site. Default arguments specify values for optional arguments. 2) Function overloading, inline functions, and default arguments are not supported in C, only in C++. The examples demonstrate how these features work in C++ but would cause errors in C. 3) The benefits of overloaded functions, inline functions, and default arguments are modular and reusable code, reduced function call overhead, and optional arguments. But C does not support these object

Faster Python, FOSDEMVictor Stinner

This document summarizes two projects that aim to optimize Python performance: the AST optimizer and register-based bytecode. The AST optimizer rewrites Python abstract syntax trees to enable more optimizations than CPython's peephole optimizer. It aims to improve performance by constant folding, loop optimizations, and other transformations. The register-based bytecode project rewrites CPython's stack-based bytecode to use registers, enabling additional optimizations like common subexpression elimination and constant/attribute deduplication. Both projects showed speedups over CPython in benchmarks, but may not translate to all real applications. The document provides details on each project's approach and goals.

NS2: Binding C++ and OTcl variablesTeerawat Issariyakul

This document discusses binding variables between C++ and OTcl in NS2 simulations. It describes creating a C++ class with a variable and binding it to an OTcl variable using the bind() function in the C++ constructor. This allows modifying the variable from either domain. The document provides an example of binding a C++ variable "count_" to the OTcl variable "ocount_", creating an OTcl object, and verifying it can get and set the shared variable from OTcl or by changing it in C++.

Chapter iii(advance function)Chhom Karath

Queue data structureMekk Mhmd

The document discusses queues and their implementation and applications. It begins by describing the physical nature of queues and some real-world examples where queues are used, such as waiting in line. It then defines queues as abstract data types and common queue operations like enqueue and dequeue. The document provides examples of implementing queues using arrays and linked lists, including pseudocode for basic queue methods. It also demonstrates using queues in C# code and discusses edge cases like empty queues.

Team 6Sathasivam Rangasamy

Stack operation algorithms with exampleNamanKikani

This document discusses stacks and algorithms for common stack operations. It defines a stack as a last-in, first-out data structure where the last item added is the first removed. The key operations are PUSH to insert an item and POP to remove an item from the top. Algorithms are provided for PUSH, POP, and displaying the stack. As an example, the document shows the steps to convert an infix notation expression to postfix.

Array using recursionSwarup Boro

Stack concepts by DivyaDivya Kumari

This document discusses the stack data structure and its operations. It defines a stack as a Last In First Out (LIFO) data structure. The main stack operations are push, which inserts an element into the stack, and pop, which removes an element from the stack. It also discusses using a stack to check for matching parentheses during program parsing. The document then provides implementations of stacks using both arrays and linked lists in C, demonstrating how to perform push and pop operations on each.

My lectures circular queueSenthil Kumar

This document discusses queues and priority queues. It defines a queue as a first-in first-out (FIFO) linear data structure with elements added to the rear and removed from the front. Circular queues are introduced to address the limitation of linear queues filling up. Priority queues are also covered, with elements ordered by priority and the highest or lowest priority element always at the front. Implementation of priority queues using heaps is explained, with insertion and deletion operations having time complexity of O(log n).

Intoduction to dynamic memory allocationUtsav276

This document discusses dynamic memory allocation in C programming. It introduces the malloc, calloc, and realloc functions. Malloc allocates memory at runtime and returns a pointer to the allocated block. Calloc allocates memory for an array and initializes elements to zero. Realloc changes the size of a previously allocated memory block. The document provides examples of using these functions and notes that dynamic allocation allows memory usage to change at runtime, unlike static allocation. It also compares malloc and calloc, noting calloc initializes to zero while malloc may contain garbage values.

Heap sort & bubble sortShanmuga Raju

Heap sort is described as sorting an array using a heap data structure. It involves building a max heap from the array, moving the largest element to the end of the array after each pass, and sifting down the new root to re-establish the heap property. Bubble sort is described as repeatedly swapping adjacent elements that are in the wrong order until the array is fully sorted. Pseudocode and a C++ program are provided to implement each algorithm.

Recursion concepts by DivyaDivya Kumari

Recursion is a process of solving a problem where the solution depends on solutions to smaller instances of the same problem. Some examples that use recursion include calculating factorials, generating Fibonacci numbers, reversing a linked list, and traversing trees. A recursive function calls itself directly or indirectly. To terminate the recursion, a base case is used. The memory for each function call is allocated on the stack, with each recursive call using new memory on top of the previous call. When the base case is reached, the function returns values up the call stack and memory is de-allocated.

Queue Data Structure (w/ php egs)Roman Rodomansky

Functors, applicatives, monadsrkaippully

The document discusses functors, applicatives, and monads in Haskell. It provides examples of how functors allow lifting functions to work on container types like Maybe and Logger using fmap. Applicatives allow applying functions to multiple arguments within a container using <*>. Monads generalize applicatives by allowing chained computations through >>= and return, handling context and effects like logging.

QueueNabeel Ahsen

This document discusses queues as an abstract data type and their common implementations and operations. Queues follow first-in, first-out (FIFO) ordering, with new items added to the rear and removed from the front. Queues can be implemented using either arrays or linked lists. Array implementations involve tracking the front, rear, and size of the queue, with special logic needed when the rear reaches the end. Linked list implementations use head and tail pointers to reference the front and rear of the queue. Common queue operations like enqueue and dequeue are also described.

Lab 1rimshailyas1

The document contains two questions asking to implement data structures in C++. Question 1 asks to implement methods for a singly linked list including returning size, printing, checking containment, adding, and removing values. Question 2 asks to implement methods for a queue using an array including initializing, checking for empty/full, accessing front/back, adding, and removing elements. Sample code is provided for both a linked list and queue implementation with the required methods.

Data Structures and Agorithm: DS 09 Queue.pptxRashidFaridChishti

The presention is about the queue data structuregaurav77712

More Related Content

What's hot (20)

Functionvenkatme83

Data Structures - Lecture 6 [queues]Muhammad Hammad Waseem

The Big ThreeRoman Okolovich

Lecture05elearning_portal

Faster Python, FOSDEMVictor Stinner

NS2: Binding C++ and OTcl variablesTeerawat Issariyakul

Chapter iii(advance function)Chhom Karath

Queue data structureMekk Mhmd

Team 6Sathasivam Rangasamy

Stack operation algorithms with exampleNamanKikani

Array using recursionSwarup Boro

Stack concepts by DivyaDivya Kumari

My lectures circular queueSenthil Kumar

Intoduction to dynamic memory allocationUtsav276

Heap sort & bubble sortShanmuga Raju

Recursion concepts by DivyaDivya Kumari

Queue Data Structure (w/ php egs)Roman Rodomansky

Functors, applicatives, monadsrkaippully

QueueNabeel Ahsen

Lab 1rimshailyas1

Functionvenkatme83

Data Structures - Lecture 6 [queues]Muhammad Hammad Waseem

The Big ThreeRoman Okolovich

Lecture05elearning_portal

Faster Python, FOSDEMVictor Stinner

NS2: Binding C++ and OTcl variablesTeerawat Issariyakul

Chapter iii(advance function)Chhom Karath

Queue data structureMekk Mhmd

Team 6Sathasivam Rangasamy

Stack operation algorithms with exampleNamanKikani

Array using recursionSwarup Boro

Stack concepts by DivyaDivya Kumari

My lectures circular queueSenthil Kumar

Intoduction to dynamic memory allocationUtsav276

Heap sort & bubble sortShanmuga Raju

Recursion concepts by DivyaDivya Kumari

Queue Data Structure (w/ php egs)Roman Rodomansky

Functors, applicatives, monadsrkaippully

QueueNabeel Ahsen

Lab 1rimshailyas1

Similar to Queue oop (20)

Data Structures and Agorithm: DS 09 Queue.pptxRashidFaridChishti

The presention is about the queue data structuregaurav77712

In Class AssignmetzCST280W13a-1.pdfCST 280 In-Class Pract.docxbradburgess22840

In Class Assignmetz/CST280W13a-1.pdf CST 280 In-Class Practice – Week 13 Manually determine the configuration of the priority queue (stored as a heap) created by the following operations. Trace the following logic and define the output: enqueue(7); enqueue(17); enqueue(2); enqueue(5); enqueue(22); enqueue(19); enqueue(6); enqueue(11); enqueue(13); write the queue contents dequeue and write front item enqueue(15); enqueue(8); dequeue and write front item dequeue and write front item enqueue(24); enqueue(14); write the queue contents Part 2 Then, verify the output by implementing the algorithm by rewriting the priority queue demonstration program discussed in class. Files needed: testPQueue.cpp pqType.h heap.cpp Deliverables • This cover sheet (with your names on it) • Driver source code and output for verification program exectution. In Class Assignmetz/CST280W13b.pdf CST 280 In-Class Practice – Week 13 Use this page as a worksheet to sketch the progression of the elements up to the first split for the QuickSort algorithm. Use the middle array element as the split value: 15 34 99 42 11 41 66 23 55 93 48 Next, access the file quickSort.cpp from the course web page. Tailor the program by entering the array values above in place of the integer values used for an in-class demonstration. Be sure to adjust the index range to match the size of this array. Remember that the parameters to the QuickSort algorithm are starting and ending index values, not the size of the array. Next, insert code to demonstrate the state of the array after the first split. This should verify what you did by hand above. Insert the following code at various points within the partition function to “see” the array at various stages of processing: for (int i = start; i <= end; i++) // <== ADD cout << set[i] << ' '; cout << endl; Insert the code at these positions: int partition(int set[], int start, int end) { int pivotValue, pivotIndex, mid; mid = (start + end) / 2; swap(set[start], set[mid]); pivotIndex = start; pivotValue = set[start]; ç HERE for (int scan = start + 1; scan <= end; scan++) { if (set[scan] < pivotValue) { pivotIndex++; swap(set[pivotIndex], set[scan]); } ç HERE } swap(set[start], set[pivotIndex]); ç HERE return pivotIndex; } Finally, identify the line that matches what you concluded above. Deliverables: Deliver the following for this assignment: • This work sheet with a sketch of the array first split • Program source code with required change • Program output demonstrating array configuration after first split .

Unit 4 queueDabbal Singh Mahara

The document discusses different types of queues and their implementations. It begins by defining a queue as a first-in first-out (FIFO) data structure where elements are inserted at the rear and deleted from the front. It then covers linear and circular queue implementations using arrays, including operations like insertion, deletion, checking for empty/full, and traversal. Priority queues are also introduced, which process elements based on assigned priorities. The key types and operations of queues as an abstract data type (ADT) are summarized.

QprgsSsankett Negi

week-16xKITE www.kitecolleges.com

The document discusses the implementation of queue operations using pointers and arrays in C. It defines the queue data structure using a struct containing a data element and pointer to the next node. Functions are defined to add, remove and check for empty/full as well as display the queue elements. A similar implementation is shown using arrays instead of pointers by defining a queue struct containing the front, rear indexes and size.

Queues_0748555555555555555555555526.pptxnailapp2023

Queue(lecture8).pptxsinghprpg

The document discusses different types of queues including linear queue, circular queue, deque (double ended queue), and priority queue. It defines a queue as a list where items are inserted at the rear and deleted at the front (FIFO). Circular queues overcome limitations of linear queues by making the array circular. A deque supports insertion/deletion from both front and rear. Priority queues process elements based on priority, with higher priority elements processed before lower priority ones. Heaps provide an efficient implementation for priority queues.

Algo>QueuesAin-ul-Moiz Khawaja

1. A queue is a first-in, first-out (FIFO) data structure where items are inserted at the rear of the queue and deleted from the front. 2. Queues can be implemented using arrays or linked lists, with operations including enqueue to add an item to the rear, and dequeue to remove an item from the front. 3. Queues have many applications where processing or accessing data in a first-come, first-served order is important, such as in operating systems, communication software, and printing.

Data structure , stack , queueRajkiran Nadar

Data Structure Introduction Data Structure Definition Data Structure Types Data Structure Characteristics Need for Data Structure Stack Definition Stack Representation Stack Operations Stack Algorithm Program for Stack in C++ Linked List Definition Linked List Representation Linked List Operations Linked List Algorithm Program for Linked List in C++ Linked List Defination Linked List Representation Linked List Operations Linked List Algorithm Program for Linked List in C++

@Chapter 4 DSA Part II.pptxNuraMohamed9

This document discusses queues as a data structure. Some key points: - Queues follow the FIFO (first in, first out) principle and have two main operations - enqueue to insert at the rear, and dequeue to remove from the front. - Queues can be implemented using arrays or linked lists. Array implementation uses front and rear pointers to track the first and last elements while linked list uses pointers between nodes. - Common applications of queues include task scheduling, disk I/O handling, media playback lists, call centers, and simulation of waiting lines where the first entry is the first to be served.

DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDYMalikireddy Bramhananda Reddy

This document discusses binary search trees and provides source code to implement binary search tree traversal operations. It explains that a binary search tree is a binary tree where the left child of a node is less than the parent and the right child is greater. It provides code for preorder, inorder, and postorder traversals of the binary search tree and outputs the traversal order for a sample tree.

05 queuesRajan Gautam

Queue is a linear data structure where elements are inserted at the rear end and deleted from the front end, following FIFO (First In First Out) principle. A queue can be implemented using arrays or linked lists. The document discusses implementation of queues using static arrays and dynamic memory allocation. It also covers insertion and deletion algorithms and provides examples of queue operations using both array-based and linked list-based implementations. Circular queues are introduced as an enhancement over standard queues to avoid overflow in static array implementation.

Lec-12, 13 Quees Another implementation of Queues using ArraysAnil Yadav

Stack and queueKatang Isip

Stack and Queue data structures are described. A Stack follows LIFO (last-in, first-out) where elements can only be inserted and removed from one end. Common stack operations are push, pop, and peek. A Queue follows FIFO (first-in, first-out) where elements can only be inserted at the rear and removed from the front. Common queue operations are enqueue and dequeue. Both can be implemented using arrays or linked lists. A circular array implementation improves the efficiency of dequeuing from a queue.

queuesArrays.ppt bbbbbbbbbbbbbbbbbbbbbbbbbbRAtna29

This document discusses queues as a data structure. It defines queues as lists that only allow insertions at one end and deletions at the other end, following a First-In First-Out (FIFO) ordering. Common queue operations like add, remove, and peek are introduced. Examples of queues in computer science and real world are provided, like print job queues and lines. Implementations of queues using arrays and linked lists are briefly described.

CBSE Class XII Comp sc practical filePranav Ghildiyal

1. The document contains details of Pranav Ghildiyal, a class XII student. It includes a table of contents listing 24 programs with page numbers. 2. The programs cover concepts like arrays, structures, classes, inheritance, file handling, stacks, queues and more. Algorithms covered include sorting, searching and linked lists. 3. The document serves as an index for various C++ programs written by the student to demonstrate different concepts and data structures.

1- The design of a singly-linked list below is a picture of the functi (1).pdfafgt2012

1. The document provides code for implementing common data structures including singly linked lists, stacks, and queues. It includes class templates for each with member functions for common operations like insertion, removal, accessing elements, checking sizes, etc. 2. The code is accompanied by requirements to write functions to insert into a linked list while maintaining order, check balanced parentheses with a stack, and allow input/output of multiple queues. 3. The provided code implements core functionality while the requirements call for additional functions to utilize the data structures.

Polynomialmotilalanehrunationalinstitute.pdfyugpadhiyar2006

Queue by rajanikanthbtechsmartclass

Data Structures and Agorithm: DS 09 Queue.pptxRashidFaridChishti

The presention is about the queue data structuregaurav77712

In Class AssignmetzCST280W13a-1.pdfCST 280 In-Class Pract.docxbradburgess22840

Unit 4 queueDabbal Singh Mahara

QprgsSsankett Negi

week-16xKITE www.kitecolleges.com

Queues_0748555555555555555555555526.pptxnailapp2023

Queue(lecture8).pptxsinghprpg

Algo>QueuesAin-ul-Moiz Khawaja

Data structure , stack , queueRajkiran Nadar

@Chapter 4 DSA Part II.pptxNuraMohamed9

DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDYMalikireddy Bramhananda Reddy

05 queuesRajan Gautam

Lec-12, 13 Quees Another implementation of Queues using ArraysAnil Yadav

Stack and queueKatang Isip

queuesArrays.ppt bbbbbbbbbbbbbbbbbbbbbbbbbbRAtna29

CBSE Class XII Comp sc practical filePranav Ghildiyal

1- The design of a singly-linked list below is a picture of the functi (1).pdfafgt2012

Polynomialmotilalanehrunationalinstitute.pdfyugpadhiyar2006

Queue by rajanikanthbtechsmartclass

Queue oop

1. Queue Prepared by: Eng. Ahmed & Mohamed Taha

2. Agenda  Introduction to Queue.  How Queue works.  Operations performed on Queue.  Queue Implementation.

3. Introduction to Queue  Queue is an ordered collection of items in which new data items are added at the end, or tail, of the queue while other data are removed from the front, or head, of the queue. For this reason, a queue is referred to as a FIFO structure (First-In First-Out)  The main primitive operations of a queue are known as:  Add adds a new node  Remove removes a node  Additional primitives can be defined:  IsEmpty: reports whether the queue is empty  IsFull: reports whether the queue is full  Initialize: creates/initializes the queue  Destroy: deletes the contents of the queue (may be implemented by re-initializing the queue)

4. Introduction to Queue Company Logo

5. Introduction to Queue Company Logo

6. Introduction to Queue Company Logo

7. Queue Implementation using Object Oriented Programming

8. Queue Implementation using Array #include <iostream.h> #include <conio.h> #include <stdlib.h> #define max_size 100 #define TRUE 1 #define FALSE 0 typedef int boolean; /************************************/ Class queue { private: int items[max_size]; int front,rear; public: };

9. Queue Implementation using address /////////////////////////////funcions // Initialize Function void queue:: queue() { front=0; rear=-1; } // Is_empty Function boolean queue:: is_empty() { if (rear < front) return TRUE; return FALSE; }

10. Queue Implementation using address // Insert Function void queue:: insert(int item) { if (rear == max_size-1) { cout<<"Queue is Overflow"; exit(0); } else rear++; items[rear]=item; }

11. Queue Implementation using address // Remove Function int queue:: remove() { if (is_empty()) { cout<<"Queue is underflow"; return -1; } int item=items[front]; front++; return item; }

12. Queue Implementation using address // Print all elements Funcion void queue:: print_all_elements () { cout<<"the current items of the queue are:"<<endl; for(int i=front;i<=rear;i++) cout<<items[i]<<" "; cout<<endl; }

13. Queue Implementation using address void main() { clrscr(); queue q; q.insert(1); q.insert(2); q.insert(3); q.insert(4); q.print_all_elements(q); int val=q.remove(); val=q.remove(); q.print_all_elements(); q.insert(5); q.insert(6); q.print_all_elements(); getch(); }

Queue oop

Recommended

More Related Content

What's hot (20)

Similar to Queue oop (20)

Queue oop