1. Write a function (heapify) to satisfy the heap property from an array A. In order to implement the heapify function, please implement the below functions first: int getParent (int index); // Purpose: calculates the index of a node's parent node // Post: integer value returned to caller int getLeftChild (int index) ; // Purpose: calculates the index of node's left child // Post: integer value returned to caller int getRightChild (int index) ; // Purpose: calculates the index of a node's right child // Post: integer value returned to the user void swap (intá iteml, int& item2); // Purpose: exchanges two values // Post: iteml = old item2 and item2 = old iteml, results // returned through reference parameter 2. Write a function to build a heap (buildHeap). 3. Test output with an array A[20] = {4,1,3,2,16,9,10,14,8,7}. 4. Create a function to insert numbers to the heap. 5. Test the insert function with inserting 20 and 17 sequentially to the heap (heapInset function should be called to insert 20 and 17- Do not use build_heap function in the heap_insert function).

1. Write a function (heapify) to satisfy the heap property from an array A. In order to implement the heapify function, please implement the below functions first: int getParent (int index); // Purpose: calculates the index of a node's parent node // Post: integer value returned to caller int getLeftChild (int index) ; // Purpose: calculates the index of node's left child // Post: integer value returned to caller int getRightChild (int index) ; // Purpose: calculates the index of a node's right child // Post: integer value returned to the user void swap (intá iteml, int& item2); // Purpose: exchanges two values // Post: iteml = old item2 and item2 = old iteml, results // returned through reference parameter 2. Write a function to build a heap (buildHeap). 3. Test output with an array A[20] = {4,1,3,2,16,9,10,14,8,7}. 4. Create a function to insert numbers to the heap. 5. Test the insert function with inserting 20 and 17 sequentially to the heap (heapInset function should be called to insert 20 and 17- Do not use build_heap function in the heap_insert function).

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter17: Linked Lists

Section: Chapter Questions

Problem 2PE

See similar textbooks

Similar questions

This chapter describes the array implementation of queues that use a special array slot, called the reserved slot, to distinguish between an empty and a full queue. Write the definition of the class and the definitions of the function members of this queue design. Also, write a program (in main.cpp) to test various operations on a queue. //Header file QueueAsArray #ifndef H_QueueAsArray #define H_QueueAsArray #include <iostream> #include <cassert> using namespace std; template<class Type> class queueType { public: const queueType<Type>& operator=(const queueType<Type>&); // overload the assignment operator void initializeQueue(); int isEmptyQueue() const; int isFullQueue() const; Type front() const; Type back() const; void addQueue(Type queueElement); void deleteQueue(); queueType(int queueSize = 100); queueType(const queueType<Type>& otherQueue); // copy constructor…
Assume the function: void F(stack<T> &S){ } and we send a stack S to the function F, as a result of it إختر أحد الخيارات: a. Both (copy constructor and destructor) should be called b. Both (copy constructor and destructor) should not be called c. Destructor should be called d. Copy constructor should be called
Assume the function: void F(stack<T> &S){ } and we send a stack S to the function F, as a result of it Select one: a. Copy constructor should be called b. Both (copy constructor and destructor) should be called c. Both (copy constructor and destructor) should not be called d. Destructor should be called
Suppose a node of a linked list is defined as follows in your program: typedef struct{ char data; struct Node* link; } Node; Write the definitions of two functions (i) Node* pop(Node* top) – which removes the top element of the stack, and (ii) bool compare(Node* topA, Node* topB) - which returns true if the both stacks have identical data. The function returns false if the data in both stacks are not identical. In the function definitions, top, topA, and topB point the top elements of corresponding stacks. You must use the following function definitions in your answer. The peek function has already been defined. You need to write the definition of pop and compare functions. You are not allowed to modify the parameters and/or return types of the functions. Node* pop(Node* top){ //write the function definition } char peek(Node* top){ return top->data; } bool compare(Node* topA, Node* topB){ //write the function definition } Write the time complexity in Big-O notation…
Define the function (doubleBubbleLst lst). This function should resolve to a list of sublists, where each sublist holds a single element from lst and all sublists from lst are also bubbled, so that every list and sublist has no atoms. This is the deep recursion version of bubbleLst. For example: (doubleBubbleLst '(1 2 (3 4)) ) resolves to '((1) (2) (( (3) (4) ))).
Assume the following list: 30, 45, 1, 26, 90, 5, 85, 35, 20, 41, 38, 72, 11, 33, 49 Using the function buildHeap as given in this chapter, convert the list into a heap. Show the resulting list after three passes of heapsort. (Use the heapify procedure as given in this chapter.) One pass:________________________________________________ Two passes:_______________________________________________ Three passes:______________________________________________ //---------buildHeap function-------------------- template <class elemType> void arrayListType<elemType>::buildHeap() { for (int index = length / 2 - 1; index >= 0; index--) heapify(index, length - 1); }//end buildheap //-----------heapify function------------------ template<class elemType> void arrayListType<elemType>::heapify(int low, int high) { int largeIndex; elemType temp = list[low]; //copy the root node of the subtree largeIndex = 2 * low + 1; //index of the left child while (largeIndex <= high)…
PP 12.4 The top variable in the chapter's array implementation is kept above the stack's actual top by pointing to the following array position. Change the array implementation so that stack[top] actually refers to the stack's top. PP 12.5 A data structure known as a drop-out stack functions exactly like a stack, with the exception that if the stack size is n, the first element is lost when the n + 1 element is pushed. Apply an array to a drop-out stack. (Hint: It would make sense to implement a circular array.)
Write c++ code Implement a class (template) SortedSet which is actually a singly linked list with head and tail pointers. It will store data in ascending order while disallowing duplicate data. Implement the following member functions for this class.1. Default Constructor. SortedSet();2. An insert function that will insert the data such that resultant set is in ascending order. Duplicate data will not be allowed. void insert(T const data);3. A delete function that will delete the element at the given index. void delete(int const index);4. A print function that will print the contents of the sorted set. void print() const;5. A union function that will be passed another sorted set. This function will take union of two setsand store the result in the first set. void union(SortedSet<T>const &otherSet);For example:SortedSet a; (suppose it has 1, 2, 3, 4, 10, 50)SortedSet b; (suppose it has 6, 10, 11)a.union(b); (a will now contain 1, 2, 3, 4, 6, 10, 11, 50)6. An intersection…
2.2.14 Combining sorted queues. Create a static function that accepts two sorted queues as parameters and returns a queue formed by merging the queues into sorted order. 2.2.15 Mergesort from the bottom of the queue. Create a bottom-up mergesort implementation using the following method: Create N queues, each containing one of the things, given N items. Make a queue out of the N queues. Then, repeat Exercise 2.2.14's merging process on the first two queues, and finally, reinsert the combined queue.Repeat until there is just one queue in the queue of queues.
Design a function bool validateStackSequences(const std::vector<int>& v) that takes an int vector with distinct values, and returns if values in v could be a valid sequence of stack operations You may assume the input values are always{1, 2, 3, 4, 5}. #include <vector> #include <stack> #include <iostream> // TODO: implement this function bool validateStackSequences(const std::vector<int>& v) { if (v.size() % 2 != 0) return false; std::stack<int> s; int i = 0; int j = v.size() - 1; while (i <= j) { if (v[i] == v[j]) { i++; j--; } else if (!s.empty() && s.top() == v[j]) { s.pop(); j--; } else { s.push(v[i]); i++; } } return s.empty(); } int main(){ // use following code snippet for testing // expected output: // true // false // true // false // true std::cout << std::boolalpha << validateStackSequences({5, 4, 3, 2, 1}) << std::endl; std::cout <<…
C++ Consider the following function as a property of a LinkedBag that contains a Doubly Linked List. Assume a Node has pointers prev and next, which can be read and changed with the standard get and set methods. Assume that the doubly linked list is: 1 <--> 2 <--> 3 <--> 4 <--> 5 <-->6 If you are uncertain what the above diagram depicts, it is a doubly linked list such that: The head of this doubly linked list is the node that contains the value 1. The tail of this doubly linked list is the node that contains the value 6. The 3rd node in this list contains the value 3. The contents of this list are the values 1 through 6 in sequential order. The following questions are regarding the linked list after after the test_function is run. A. The head of the list after the test_function is run contains the value: B. The tail of the list after the test_function is run contains the value: C. The 3rd node in the list after the test_function is run…
Write the following code in C 1. Create a struct with at least 3 fields - any struct you want but explain it in your comments in the code. Populate at least 10 elements in an array of elements of this struct type with a limit of 1000 elements. 2. Create an array on the heap to store the same number of populated elements from the stack array. 3. Copy the values from the stack array into the dynamic array. The program will output the contents from each array, one at a time. 4. Finally, create a BIN file to store the contents of the array on the heap.