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.

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

Write static <T> void quickSort(T[] array, Comparator<T> cc) Implement the version that picks pivots at random. This makes it a randomized algorithm and expect it to run in O(nlog⁡n) time. Remember that the Comparator<T> interface in Java defines how we can compare objects of type T. The interface expects the existence of a method int compare(T o1, T o2) which compares o1 and o2 for order. More specifically: if o1 < o2, then compare returns a negative value; if o1 == o2, then compare returns 0 (this should be consistent with .equals); if o1 > o2, then compare returns a positive value.
Write a static method named SmallestEvenStackQueueToList that takes two parameters: an array-based unbounded queue of integers as its first parameter and an array-based bounded stack of integers as its second parameter. The method should find the smallest even integers from all corresponding values in the stack and queue and save them into an object of type ArrayUnsortedList and return this object from the method. If two corresponding elkments in the stack and queue are odd integers, then add the value -1 to the unsorted list. Assume that stack and queue have the same size. Examplel: if the queue has: 1 5 4 4 9 8 10 If the stack has: 4 3 10 9 5 20 Then the unsorted list has: 4 -1 4 4 -1 10 The stack and queue must become empty after calling the method. //-----Paste SmallestEvenStackQueueToList code below this line 2.
Please help Java
CODE IN JAVA You have probably heard about the deque (double-ended queue) data structure, which allows for efficient pushing and popping of elements from both the front and back of the queue. Depending on the implementation, it also allows for efficient random access to any index element of the queue as well. Now, we want you to bring this data structure up to the next level, the teque (triple-ended queue)!
For the AVLTree class, create a deletion function that makes use of lazy deletion.There are a number of methods you can employ, but one that is straightforward is to merely include a Boolean field in the Node class that indicates whether or not the node is designated for elimination. Then, your other approaches must take into consideration this field.
Write a method max() which take a generic singly linked list as an argument and returns the maximum element reference in the list. If the list is empty, please throw an empty collection exception. The method prototype is defined as follows. public static > T max(SingleLinkedList list) throws EmptyCollectionException You can use any of public methods in these following three classes: 1. The SingleLinkedList class diagram is as follows: SingleLinkedNode 1-SingleLinkedNodenext -T element O• SingleLinkedNodeg 9+SinglelinkedNode(T elem) +SingleLinkedlNode first SingleLinkedNode last int numNodes +SingleLinkedList) +void addFirst(T element)
Given a reference to the head of a linkedlist of integers which is instantiated from MyLinkedList class. Assume that the linkedlist has an even number of nodes >2 and only two of the nodes has a duplicate value. Write a Java method called swapDuplictes that swaps the first duplicate with the node before the last node in the linkedlist and swaps the second duplicate with the last node in the linked list. Note: You are not allowed to exchange values of nodes or use any of the add, insert, or remove methods from MyLinkedList class. You have to perform the task by moving the next link. consider the following example of a linkedlist containing six nodes: Before calling the method head tail After calling the method head tail
rite a method called samePosition in a class called StackExt that receives two parameters st1 and st2 of type ArrayStack and a third parameter pos of type int. The method returns true, if stack st1 and st2 contains the same value in position pos. Otherwise, the method returns false. Assume that both stacks st1 and st2 contain same number of elements. Assume that the position of the top element is 0 and increases by 1 for each subsequent element. The elements of both stacks st1 and st2 must remain in the original relative positions in the stacks at the end of the method. Use common stack operations only such as push, pop, peek, isEmpty, constructor and copy constructor. You can create temporary objects of type ArrayStack in your method. Example: top st1: 4 5 3 10 8 st1: 5 9 4 10 1 If the pos is 3, then both stacks contain 10 in position 3. The method returns true. If the pos is 1, then st1 contains 5 and st2 contains 9 in…
To help manage the wizarding world, we need to write a reverse method. For the general purpose, let us write a generic reverse method. Namely, given an array of T objects, the reverse method would use a stack to reverse these T objects and return a new ArrayList with these T objects in reverse order. The generic method prototype is as follows: public <T> ArrayList<T> reverse(T[] wizards) throws Exception; To help reverse Hogwarts students' names, we can invoke the method as follows: reverse({"Harry Potter", "Ronald Bilius", "Hermione Jean Granger"}) , where {"Harry Potter", "Ronald Bilius", "Hermione Jean Granger"} is an array input and it will return an java.util.ArrayList instance, containing "Hermione Jean Granger" as the first element, "Ronald Bilius" as the second element, and "Harry Potter" as the third element. Task 1. Please use a Stack to implement the generic reverse method: public ArrayList reverse(T[] wizards) throws Exception First write…
Write the code in C++
For this Problem, you will implement a brute force solution to the maximum-subarray problem that runs in O(n2) time (i.e., your solutions should have two nested loops). You will implement this solution for an array of ints and a simple LinkedList of ints. To get started, import the two starter files into the subarray package you created in a new Java Project. Please do not change any of the method signatures or any code in the provided LinkedList class. Implement the two methods described below. public LinkedList findMaximumSubList(LinkedList nums) This method should return a new LinkedList that represents the maximum sublist of the given LinkedList, nums. For example, the maximum sublist of 13->-3->-25->-20->-3->-16->-23->18->20->-7->12->-5->-22->15->-4->7 is 18->20->-7->12 public int[] findMaximumSubArray(int[] nums) This method should return a new int[] that represents the maximum subarray of the given int[], nums. For example,…
Modify the generic Pair.java class in two ways: Make it so that both values have the same type Add a method swap that swaps the first and second elements of the pair Examples:Pair<Integer> intPair = new Pair<>(17, 19);intPair.getFirst(); // returns 17intPair.getSecond(); // returns 19intPair.swap();intPair.getFirst(); // returns 19intPair.getSecond(); // returns 17Pair<String> strPair = new Pair<>("Erick", "Valdez");strPair.getFirst(); // returns "Erick"strPair.getSecond(); // returns "Valdez"strPair.swap();strPair.getFirst(); // returns "Valdez"strPair.getSecond(); // returns "Erick" Pair.java /*** This class collects a pair of elements of different types.*/public class Pair<T, S> {private T first;private S second;/*** Constructs a pair containing two given elements.* * @param firstElement the first element* @param secondElement the second element*/public Pair(T firstElement, S secondElement) {first = firstElement;second = secondElement;}/*** Gets…