Given a BST, which traversal method would allow you to turn it into a min heap using N heap insertions calls in O(N) worst case runtime? Implement the process described above in as-close-to-Java code/no English, write the method "changeBSTintoMinHeap" which takes in a BSTNode (i.e. root) and returns a minHeap. You may use helper methods. You can use code from slides to help you. You must cite all the sources you used. You cannot simply copy and paste code from other resources (besides slides). Your work must be your own.

Given a BST, which traversal method would allow you to turn it into a min heap using N heap insertions calls in O(N) worst case runtime? Implement the process described above in as-close-to-Java code/no English, write the method "changeBSTintoMinHeap" which takes in a BSTNode (i.e. root) and returns a minHeap. You may use helper methods. You can use code from slides to help you. You must cite all the sources you used. You cannot simply copy and paste code from other resources (besides slides). Your work must be your own.

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

In python. Write a LinkedList class that has recursive implementations of the add and remove methods. It should also have recursive implementations of the contains, insert, and reverse methods. The reverse method should not change the data value each node holds - it must rearrange the order of the nodes in the linked list (by changing the next value each node holds). It should have a recursive method named to_plain_list that takes no parameters (unless they have default arguments) and returns a regular Python list that has the same values (from the data attribute of the Node objects), in the same order, as the current state of the linked list. The head data member of the LinkedList class must be private and have a get method defined (named get_head). It should return the first Node in the list (not the value inside it). As in the iterative LinkedList in the exploration, the data members of the Node class don't have to be private. The reason for that is because Node is a trivial class…
USE PYTHON
Continuing on from your implementation of the PriorityQueue class, add the method create_heap_fast (self, values) which takes a Python list as a parameter. This method should put elements from the Python list into the priority queue without using the insert method. The Big-O of this method is O(n). The method should do the following: • Insert each element from the parameter list and append it to the binary heap. • Set the size to the number of elements in the parameter list. • Get the starting index position (i.e. last element which has a child, size // 2). • Rearrange the elements starting from the above index position by calling the percolate_down() method. • Keep rearranging and working backwards towards the root. Note: submit the entire class definition. You can assume that the parameter list is not empty. For example: Test pq PriorityQueue () keys [9, 5, 8, 6, 3, 2] pq.create_heap_fast(keys) = = print (pq) Result [0, 2, 3, 8, 6, 5, 9]
Given a BST, which traversal method would allow you to turn it into a min heap using N heap insertions calls in O(N) worst ca se runtime? Implement the process described above in as-close-to-Java code/no English, write the method "changeBSTintoMinHeap" which takes in a BSTNode (i.e. root) and returns a minHeap. You may use helper methods.
code
Java's LinkedList provides a method listlterator(int index) returning a Listlterator for a list. Declare a variable of LinkedList of integer numbers and write a fragment of Java code to compute and print the sum of the numbers on the list. Do not write code to insert elements to the list and assume that the list already has elements on it. You must only use an iterator obtained from the list (you can not use the get(int index) method) .
Design a more efficient version of HeapVector that keeps its values in order only when necessary: When values are added, they are appended to the end of the existing heap and a nonHeap flag is set to true. When values are removed, the nonHeap flag is checked and the Vector is heapified if necessary. What are the worst-case and best-case running times of the add and remove operations?