Unnamed: 0 int64 1 5.86k | Question stringclasses 24
values | Sample ANS stringclasses 24
values | Student ANS stringlengths 1 1.06k | Score float64 0 2.5 |
|---|---|---|---|---|
2,136 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack when we have to process data in linear manner | 2 |
2,137 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack Data structure is of LiFo type data structure i.e. \nLast in first out type it is used in many algorithms but the main use of stack is while doing problems \nthat use recursion as the last call of any recursive function will be executed first | 2 |
2,138 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks are used on the concepts of last in first out which includes a data structure in which element which is added first come out last and the element which is inserted at lsst is first out | 2 |
2,139 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | The approach to develop algorithms depends on the problem we are solving that is given to us. An appropriate data structure is chosen, multiple of them can be used as such. And then we try to reach the end goal of the solution using the least amount of traversal or time complexity and manipulate our data accordingly. ... | 2 |
2,140 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | A Stack can be used for evaluating expressions consisting of operands and operators. Stacks can be used for Backtracking, i.e., to check parenthesis matching in an expression. It can also be used to convert one form of expression to another form. It can be used for systematic Memory Management.\n | 1 |
2,141 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | LIFO data structures. Last in First Out.\nSo we can use stack when we want to compare an element with its next element. We can solve the problem in linear time complexity and linear space complexity. Stacks are very useful in questions where we are dealing with piles or related scenarios. Like for example two piles of ... | 1 |
2,142 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks are used to store large amount of data.\nStacks are very much important data structure as it has unique property of LIFO. | 1 |
2,143 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack is a modification of array which follow LIFO(Last in first out )property.\nWe use stack data type when we need these operations like in BFS algorithm we need parent node information which is visited lastly so we use stack for this so we can delete that element which is used lastly. | 1 |
2,144 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stack as a memory to store elements or usually to store large amounts of data | 1 |
2,145 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | There are certain problems which can be solved very easily using stacks in place of array because of it works on the principle of LIFO(Last In First Out). | 1 |
2,146 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | For secondary or auxiliary storage to store some particular values, \nStack operates on LIFO - Last In, First Out. | 1 |
2,147 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks are last in first out data structure when we use recursive functions stacks are used by recursion or whenever we need functionality like last in first out we use stack | 2 |
2,148 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks is used as a better substitute to solve certain problems in place of using an array | 2 |
2,149 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack is used to implement linked lists. In place of arrays , stack is better suited to solve certain problems. | 2 |
2,150 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stack works on the principle of LAST IN FIRST OUT. when we want to use LIFO type of data structure we use stack | 1 |
2,151 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stacks for the cases where we need to solve problem according for LIFO(last in first out ).In other words, we use it where we need to solve the problem by solving for sub problems. We solve the main problem in the last and sub problems firstly. | 2 |
2,152 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks when we want to access the last element added in the data structure ,i.e. we want to use LIFO principle. | 2.5 |
2,153 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stacks to store data in a way such that it can leave or enter | 2.5 |
2,154 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | The stack is - last in first out, it mean we are going to fill the stack with data but if we take the data from stack it will give the lasted data which have been inserted in the stack. | 2.5 |
2,155 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack is used in arrays it used sometimes for sorting ,deleting the index given term and it works like first in last out for this approach it solve easily | 0 |
2,156 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks to store data in a linear fashion and retrieve data in Last In First Out manner. | 2.5 |
2,157 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stack to store data, it is follows the principle of LIFO; that is last in first out. The element we enters at last should be pop out first. | 2.5 |
2,158 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack in an algorithm whenever we need to have a track of the previous element in the algorithm | 2.5 |
2,159 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Since stacks follow the principle of LIFO which makes insertion very easy in stack .Function by default use stack data structure. | 2.5 |
2,160 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks are used when we need a data structure which requires LIFO(Last in first out) Lets assume there is a problem in which we need values for the last added data in our query so by using stack it will help us to reduce the time complexity | 2.5 |
2,162 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stack when we have LIFO priority i.e. data that comes last executes first. Example : in our printers. | 2.5 |
2,163 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stacks in cases where we need to traverse a particular data in a sequential manner and at the same time store the data from that given data in a paricular sequence as per the conditions. For example we us e stack stack to traverse a string and convert it to infix to post fix there we need satck because stack all... | 2.5 |
2,164 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks because it follows last in first out approach | 0.5 |
2,165 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stack is data structure which uses last in first out approach. it gives data that is added most latest in the data structure. it has various applications and is used to solve many famous problem such as tower of hanoi . it is also used by operating system to set priority of tasks | 2.5 |
2,166 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack is a data structure that allow its data member to pop out in a LIFO manner which means the last in first out which translates to an opposite of what queue does. | 2.5 |
2,167 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack are Last In First Out or LIFO data structures. Whatever comes last in the stack will leave first and correspondly with other elements in the stack. They are often used in DFS or depth First search. | 2.5 |
2,169 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | We use stacks when we want to always access the last element that went in the stack while performing pop operation. (LIFO) | 2.5 |
2,170 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks to store data \nwhen output is required in in lifo manner | 2.5 |
2,171 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks to easy our programing, | 0 |
2,172 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | as stacks works on the principle of LIFO (last in first out)\nfor eg:- if you have assign the various trolleys (numbered from 1 to 50) in a mall to the customers coming \nso we can no. the first customer with 50 and next will be assigned with 49 and so on. | 2.5 |
2,173 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | using stacks , we can easily search an element | 0 |
2,174 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks works on the principle of FIRST IN LAST OUT | 1 |
2,175 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack for swapping values e3asily. | 0 |
2,176 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks are use to organize the data in a sequence so that it can be accessed easily \nis stack data is arranged in the form of fifo(first in first out ) \n | 0 |
2,177 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks are used when we have to follow the Last In First Out(LIFO) principle with the given data, i.e. when the latest data holds the greater priority to be taken out.\nSome of the uses are:-\n# DFS(Depth First Search)\n# Tower of Hanoi\n# In Prefix, Postfix and Infix problems | 2.5 |
2,178 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks are linear data structure which are used to store the data | 0 |
2,180 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack to arrange the element it flows first in first out policy in which a element which come first will terminate first. | 0 |
2,181 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks are the data structures used for storing data and impliment it by following the property of LIFO (last in first out) | 2.5 |
2,182 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stack is a type of data structure use to store data | 0 |
2,183 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | because stacks works on last in first out so stacks are useful in graph traversals and other searching techniques. push, pop etc are also used in stacks | 2 |
2,184 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks to perform the problem in less time interval, their are predefined stl functions, we also use push and pop approach in stack for the functioning of the problem. | 1.5 |
2,186 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks can be used for traversal. Stacks can also be used to store data. It uses the Last In First Out Principle. Stacks are used in recursion, the undo - redo feature, etc . | 2 |
2,187 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks is used to store the extra data of some set that is not in use but can be required in further research. | 0 |
2,188 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | like there are some problems we face while working on arrays that is when we want add more items in array we need to preallocate the memory whereas in stacks we need no pre allocation and we can add or remove any item at that instant, | 2 |
2,189 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack , to solve the problems in FILO form , like n number of plates are kept in such a manner that the first plate in the last and last plate which inserted in last , chosen to first. | 2 |
2,190 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | the stack data structure is used when we need a first in first out type of algorithm for our program.\nthe stack library is easy to understand and use. | 0 |
2,191 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stack to store a data in a a database in a ferment of form of fist in last out it help to optimizer the performance and the result of the given problem | 1 |
2,192 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | Stacks can be use dto | 0 |
2,193 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | stacks provide fist in fist out FIFO approach that way we use stacks | 1 |
2,194 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | last in first out method | 1 |
2,195 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | we use stacks for problems which require FIFO and for the prefix and suffix problems too . | 0 |
2,196 | Why do we use stacks? | Stacks follows LIFO method and addition and retrieval of a data item takes only Ο(n) time. Stacks are used where we need to access data in the reverse order or their arrival. Stacks are used commonly in recursive function calls, expression parsing, depth first traversal of graphs etc. | the purpose of using stack is to store the data in the present file | 0 |
2,197 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue(addition of elements),dequeue(deletion of elements) | 2.5 |
2,198 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | operations that can be performed on Queues are \ninsert a node from end\nremove a node from beginning\nremove a node from middle\nsearch a given node\ndelete a node from beginning \ndelete a node from end | 2.5 |
2,199 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | some common operation which can be perfomed in queues are inserting an element in a queue ,deleting an element from the queue | 1.5 |
2,200 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | 1) Insertion: Inserts at the top of queue\n2) Deletion: Deletes the first element of the queue\n3) finding the topmost element\n4) Searching: Find the topmost element, if not correct delete it and continue | 1 |
2,201 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue\ndequeue\nsort\n | 2.5 |
2,202 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | The operations that can be performed on queues are enqueue , dequeue, and to check whether it is empty we can call isEmpty() function. we can also do searching in queues. | 2.5 |
2,203 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Enqueue( )\nDequeue( )\npeek( )\nisfull( )\nisnull( ) | 2.5 |
2,204 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | . searching an element \n. sorting an element | 2.5 |
2,205 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Following operations can be performed on queue\n- Insertion of node (enqueue)\n- Deletion of node (dequeue)\n- Searching\n- Sorting | 2.5 |
2,207 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | operations that are performed on queues are as follows-\n1. is empty(); \n2. is full();\n3. insert(); // to insert value in the queue\n4. delete(); // to delete values from queue | 2.5 |
2,208 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | 1) top\n2) isempty\n3) merging of queue\n4) pop\n5) push \n | 2.5 |
2,209 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | The basic operation of queues is to store data in such form by arranging its minimum and maximum data in according to priority queue.\npop\npush\ndeletion\ninsertion\n | 1 |
2,210 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Since Queue works on FIFO- first in first out mechanism we can perform functions on it like PUSH (to enter data) and POP(to remove the data). | 2.5 |
2,211 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | operations that can be performed on queue are :\n- dequeue\n- enqueue\n | 2.5 |
2,212 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue\n- dequeue\n- peek | 2.5 |
2,213 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | queue follows FIFO i.e first in first out\n\noperations that can be performed are:\n1. insert data in queue\n2. retrieve data from the queue | 2.5 |
2,214 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | (LIFO).\nIn this, if we enter/push the values at the last of the stack then the first value will be returned. | 2.5 |
2,215 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | insertion, deletion, extract min ,extract max can be done on queue | 1.5 |
2,216 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | push, pop can be performed | 2 |
2,217 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Enqueue , Dequeue | 2.5 |
2,218 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue and dequeue are the very common operations that can be performed on queues | 2.5 |
2,219 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Queues are type of data structures which use the mechanism of First In First Out. the operations which can be performed on queues can be \n1.Enqueue: entering particular element in the queue \n2.Dequeue: deleting the particular element from the queue | 2.5 |
2,220 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Queues are data structures which follow FIFO ( first in first out ). Operations that can be performed on queue are :\ni) push() : inserts data in queue\nii) pop() : deletes data in queue which lies at first position (i.e. inserted first) | 2.5 |
2,221 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue ,dequeue ,traverse , get size , reverse , search | 2.5 |
2,222 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueue: To add an element to the queue.\ndequeue: To delete and element from the queue.\nfirst: To find the first element in the queue. | 2.5 |
2,223 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Insertion, Deletion, Traversal | 2.5 |
2,224 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | push, pop and finding the address ( using iterator) of an element in queues. | 2.5 |
2,225 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | there are several operation that can be performed on Queues :\n1) pushing element into it.\n2) popping element from it.\n3) find address(iterator) of an element of Queues.\netc.\n | 2.5 |
2,226 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | On queues, we can perform post-fix, pre-fix conversions, Breadth First Search. | 2.5 |
2,227 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | pushing, popping are some operations which can be performed on queues | 2.5 |
2,228 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Queues :First in first out (FIFO)\nwe can perform various operation on queues like:\n1)enqueue (to insert a element in queue)\n2)dequeue(to delete a element in queue) | 2.5 |
2,230 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Queues help us to perform certain operations which are pushing and popping a particular element from the queue to get the order and element we want. | 2.5 |
2,231 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | \nOperations that can be performed on queues are \ninsertion, deletion, function call, | 1.5 |
2,232 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Operations that can be performed on a queue are enqueue (adding an element to the end of the queue) and dequeue (removing the element at the starting of the queue) | 2.5 |
2,233 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | enqueqe, dequeue | 2.5 |
2,234 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | The are many operations which can be performed in queue like searching and sorting but the most important one is FIFO (Fist In First Out ) method.\nIn FIFO method the element which inserted first should be deleted first. | 2.5 |
2,235 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | or \ | 0 |
2,236 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | we can push an element in the queue on the FIFO principle using push and also pop the last element inserted using pop. | 1 |
2,237 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Enqueue (Insertion into queue)\nDequeue (Deletion from queue)\nFront (To print the front of the queue) | 2.5 |
2,238 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Queues can be used in the cases when we require to use the concept of LIFO (last in first out). For example shortest job first , breadth first search in graphs, level order traversal of trees etc. | 2.5 |
2,239 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Sorting can be performed so amazingly on queues, simple functions like push and pop can be use to sort out an array of the given input by the user.\n | 2.5 |
2,240 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | Operation that can be performed on queue are:\n- Dequeue (delete)\n- Enqueue (insert)\n- Disjoint-set operations: -union -find | 2.5 |
2,241 | What operations can be performed on Queues? | The below operations can be performed on a stack – (1) enqueue() − adds an item to rear of the queue (2) dequeue() − removes the item from front of the queue (3) peek() − gives value of front item without removing it (4) isempty() − checks if stack is empty (5) isfull() − checks if stack is full | A queue works on the basis of first come first serve and it performs various dynamic operations . | 2.5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.