Table 9.2 compares the running times of the methods of a priority queue realized by means of a sorted and unsorted list, respectively. We see an interesting trade- off when we use a list to implement the priority queue ADT. An unsorted list supports fast insertions but slow queries and deletions, whereas a sorted list allows fast queries and deletions, but slow insertions. Operation len is empty add min remove_min Unsorted List Sorted List 0(1) O(1) 0(1) O(1) 0(1) O(n) 0(1) 0(1) O(n) O(n) Table 9.2: Worst-case running times of the methods of a priority queue of size n, realized by means of an unsorted or sorted list, respectively. We assume that the list is implemented by a doubly linked list. The space requirement is O(n).

Table 9.2 compares the running times of the methods of a priority queue realized by means of a sorted and unsorted list, respectively. We see an interesting trade- off when we use a list to implement the priority queue ADT. An unsorted list supports fast insertions but slow queries and deletions, whereas a sorted list allows fast queries and deletions, but slow insertions. Operation len is empty add min remove_min Unsorted List Sorted List 0(1) O(1) 0(1) O(1) 0(1) O(n) 0(1) 0(1) O(n) O(n) Table 9.2: Worst-case running times of the methods of a priority queue of size n, realized by means of an unsorted or sorted list, respectively. We assume that the list is implemented by a doubly linked list. The space requirement is O(n).

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter18: Stacks And Queues

Section: Chapter Questions

Problem 16PE: The implementation of a queue in an array, as given in this chapter, uses the variable count to...

See similar textbooks

Similar questions

The bounded-buffer solution in the below code uses a last-in-first-out strategy (LIFO).Change the code to implement a FIFO (First-in-First-out) strategy. You may use the (in,out) pointer method(using semaphores to test if the queue is full or empty shouldalleviate the problem of only using up N-1 locations) or implement a FIFO queue. Usethe correct counting semaphore implementation. C code below ******************************************************************************************************************************* #include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <semaphore.h>#define SIZE 5#define NUMB_THREADS 6#define PRODUCER_LOOPS 2typedef int buffer_t;buffer_t buffer[SIZE];int buffer_index;pthread_mutex_t buffer_mutex;/* initially buffer will be empty. full_semwill be initialized to buffer SIZE, which meansSIZE number of producer threads can write to it.And empty_sem will be initialized to 0, so noconsumer can read from buffer until a…
Given a circular linked list, implement an algorithm that returns the node at the beginning of the loop.DEFINITIONCircular linked list: A (corrupt) linked list in which a node's next pointer points to an earlier node, soas to make a loop in the linked list.EXAMPLEInput:Output:A -> B -> C -> D -> E -> C [the same C as earlier]C
Given a singly linked list, print reverse of it using a recursive function printLinkedList( node *first ) where first is the pointer pointing to the first data node. For example, if the given linked list is 1->2->3->4, then output should be: 4 3 2 1 (note the whitespace in between each data value)
Suppose there are two singly linked lists both of which intersect at some point and become a single linked list. The head or start pointers of both the lists are known, but the intersecting node is unknown. Also, the number of nodes in each of the list before they intersect are unknown and both the list may have it different. List1 may have n nodes before it reaches intersection point and List2 might have m nodes before it reaches intersection point where m and n may be m = n, m > n or m < n. Give an algorithm for finding the merging point. Hints: A brute force approach would be to compare every pointer in one list with every pointer in another list. But in this case the complexity would be O(mn)
Consider a singly linked list where each node contains two fields – integerdata and node type pointer next. The head of the list and a value of the data isgiven. You have to find the node that contains the given data and delete thatnode. Data may occur at any position of the list including first or last. In caseof unavailability of the given data, you have to print a message. You have toImplement a delete operation of a singly linked list.
Given a circular linked list, implement an algorithm that returns the node at thebeginning of the loop.DEFINITIONCircular linked list: A (corrupt) linked list in which a node's next pointer points to an earlier node, soas to make a loop in the linked list.EXAMPLEInput: A -> B -> C -> D -> E -> C [the same C as earlier]Output: C
Consider a singly linked list where each node contains two fields – integerdata and node type pointer next. The head of the list and a value of the data isgiven. You have to find the node that contains the given data and delete thatnode. Data may occur at any position of the list including first or last. In caseof unavailability of the given data, you have to print a message. You have toImplement a delete operation of a singly linked list.Code in C
Consider the implementation of the Ordered Linked list class, implement the following functions as part of the class definition: ▪ index(item) returns the position of item in the list. It needs the item and returns the index. Assume the item is in the list.   ▪ pop() removes and returns the last item in the list. It needs nothing and returns an item. Assume the list has at least one item.   ▪ pop_pos(pos) removes and returns the item at position pos. It needs the position and returns the item. Assume the item is in the list.   ▪ a function that counts the number of times an item occurs in the linked list ▪ a function that would delete the replicate items in the linked list (i.e. leave one occurrence only of each item in the linked list) Your main function should do the following: ▪ Generate 15 random integer numbers in the range from 1 to 5.▪ Insert each number (Item in a node) in the appropriate position in a linked list, so you will have a sorted linked list in ascending order.▪…
The specifications for the Unsorted List ADT state that the item to be deleted is in the list. Rewrite the specification for DeleteItem so that the list is unchanged if the item to be deleted is not in the list. Rewrite the specification for DeleteItem so that all copies of the item to be deleted are removed if they exist. Do the same using a linked implementation.
Write a program for the implementation of a queue using singly linked list. The elements of the queue should be strings of length at most 20 characters. Print the queue and do the following operations on the created queue : (a) Insert a new element. (b) Delete an element from the queue.
Implement in java Build a linked list of integers and write a function that takes the reference to the head of the linked list and sorts the given linked list using bubble sort algorithm. Test Case #1 Input 5 35241 Output 35241 12345 Explanation: • First line contains input order. Second line contains sorted order Sample testcases Input 1 3 35242 Output 1 75241 17145
IN JAVA This triple-ended queue exercise can be found at https://open.kattis.com/problems/teque. The requirements for this program are compatible with those of the Kattis problem, so a solution should produce correct results when submitted on Kattis. The Triple-Ended QUEue supports four operations: push_back x: inserts the element x at the end of the TEQUE push_front x: inserts the element x at the front of the TEQUE push_middle x: inserts the element x so that the insertion index for x is (k + 1)/2 for a 0-based indexed TEQUE. get i: prints out the ith index element (0-based) of the TEQUE. The TEQUE will be implemented as a linked list. The usual implementation requirements apply along with a screenshot of the results from Kattis. Sample input 10 push_back 1 push_front 2 push_back 3 push_front 4 push_middle 5 push_back 6 get 3 push_middle 7 push_middle 8 get 5 Sample Output 1 1 Subject: Java Programming