Implement a min-heap, Data Structure & Algorithms

Assignment Help:

Description

A heap is an efficient tree-based data structure that can be used as a priority queue. Recall that the abstract data type of a priority queue has the following operations

  • size, isEmpty, min
  • insert
  • removeMin

We can describe the priority queue ADT using the following Java Entry class and interface:

1 import java.lang.Comparable;

2

3 /**

4 * When items are added to the heap, you should create an Entry object

5 * to hold the key and value and store this in the appropriate node

6 */

7 public class Entryextends Comparable,V> {

8 protected K key;

9 protected V value;

10 public MyEntry(K k, V v) { key = k; value = v; }

11 public K getKey() { return key; }

12 public V getValue() { return value; }

13 public String toString() { return "(" + key + "," + value + ")"; }

14 }

15

16 public interface PriorityQueueextends Comparable,V> {

17 /** Returns the number of items in the priority queue. */

18 public int size();

19 /** Returns whether the priority queue is empty. */

20 public boolean isEmpty();

21 /** Returns but does not remove an entry with minimum key. */

22 public Entry min();

23 /** Inserts a key-value pair and return the entry created. */

24 public Entry insert(K key, V value);

25 /** Removes and returns an entry with minimum key. */

26 public Entry removeMin();

27 }

 

The main operations (insert, removeMin) can be done in O(log n) with a heap, while the other operations of the priority queue ADT (isEmpty, size, or look up the min value) are constant time. In lectures we have seen how to implement a heap using an array-based implementation.

58_Implement a min-heap.png

Figure 1: 3-way heap example

For this assignment you must implement a min-heap using a using a tree-based implementation (similar to the binary tree class we have used in tutorials). This tree should be 3-way tree, where each node needs to have (at most) three children

Note that the definition of a 3-way heap is identical to that of a binary heap, except for allowing at most three children (see Figure ). As with a binary tree, every node must have all of its children, except for the nodes at the last levels of the tree. In more detail, your task is to

1. Design a 3-way tree structure that you will use for building your heap. You can use code provided in the book. You can use any helper data structures that you need (linked lists, arrays etc.), but you must implement the tree structure yourself.

2. Implement your design for a generic 3-way heap in a class called ThreewayHeap. You will need to implement all operations (insert, removeMin, isEmpty, etc.) in the supplied interface and skeleton for the 3-way heap. In most cases the extension is straightforward from binary heaps, with certain extra cases that you need to check.

3. Include a method in your heap to print out a visual representation in DOT format (helpful for testing/debugging purposes).

4. Design test cases for your new heap structure, used as a priority queue

5. Use the provided test code on your implementation


Related Discussions:- Implement a min-heap

The space - time trade off, The Space - Time Trade Off The best algorit...

The Space - Time Trade Off The best algorithm to solve a given problem is one that needs less space in memory and takes less time to complete its implementation. But in practic

Give the example of bubble sort algorithm, Give the example of bubble sort ...

Give the example of bubble sort algorithm For example List: - 7 4 5 3 1. 7 and 4 are compared 2. Since 4 3. The content of 7 is now stored in the variable which was h

Red black tree, red black tree construction for 4,5,6,7,8,9

red black tree construction for 4,5,6,7,8,9

Bubble sort, In this sorting algorithm, multiple swapping occurs in one pas...

In this sorting algorithm, multiple swapping occurs in one pass. Smaller elements move or 'bubble' up to the top of the list, so the name given to the algorithm. In this method,

The complexity ladder, The complexity Ladder: T(n) = O(1). It is ca...

The complexity Ladder: T(n) = O(1). It is called constant growth. T(n) does not raise at all as a function of n, it is a constant. For illustration, array access has this c

STACK, 5. Implement a stack (write pseudo-code for STACK-EMPTY, PUSH, and P...

5. Implement a stack (write pseudo-code for STACK-EMPTY, PUSH, and POP) using a singly linked list L. The operations PUSH and POP should still take O(1) time.

Asymptotic notation.., important points on asymptotic notation to remember

important points on asymptotic notation to remember

Non-recursive algorithm, Q .  Write down the non-recursive algorithm to tra...

Q .  Write down the non-recursive algorithm to traverse a tree in preorder. Ans: T he Non- Recursive algorithm for preorder traversal is written below: Initially i

Write down the algorithm of quick sort, Write down the algorithm of quick s...

Write down the algorithm of quick sort. An algorithm for quick sort: void quicksort ( int a[ ], int lower, int upper ) {  int i ;  if ( upper > lower ) {   i = split ( a,

2 way merge sort, merge sort process for an example array {38, 27, 43, 3, 9...

merge sort process for an example array {38, 27, 43, 3, 9, 82, 10}. If we take a closer look at the diagram, we can see that the array is recursively divided in two halves till the

Write Your Message!

Captcha
Free Assignment Quote

Assured A++ Grade

Get guaranteed satisfaction & time on delivery in every assignment order you paid with us! We ensure premium quality solution document along with free turntin report!

All rights reserved! Copyrights ©2019-2020 ExpertsMind IT Educational Pvt Ltd