HASHMAP TO TREEMAP

HASH MAP TO TREE MAP

EXPLANATION

HashMap and Hash Table:

HashMap is indeed implemented using a hash table data structure.

A hash table provides constant-time average-case complexity for

basic operations like insertions, deletions, and lookups (assuming

a good hash function and handling of collisions).

 HASH MAP TO TREE MAP

EXPLANATION

TreeMap and Red-Black Tree:

TreeMap is implemented using a Red-Black Tree.
A Red-Black Tree is a self-balancing binary search tree that
ensures logarithmic height and guarantees logarithmic time
complexity for basic operations like search, insert, and delete.
 HASH MAP TO TREE MAP

EXPLANATION

Performance Comparison:
HashMap is generally faster than TreeMap for insertion, deletion,
and searching, with an average-case constant time for these
operations.
TreeMap, being a balanced tree structure, has logarithmic time
complexity for these operations. This means that as the number of
elements grows, TreeMap operations will generally take more time
compared to HashMap.
 HASH MAP TO TREE MAP

EXPLANATION

Ordering:
HashMap does not guarantee any specific order of its elements. The
order of elements in a HashMap is not based on the keys or values.
TreeMap, on the other hand, maintains a sorted order based on the
natural ordering of its keys or a custom comparator if provided
during construction. This allows for efficient range queries and
iteration in a sorted order.
 HASH MAP TO TREE MAP

EXPLANATION

1.Create a TreeMap Instance:

To convert a HashMap to a TreeMap, start by creating a new TreeMap

instance. The TreeMap is a sorted map implementation in Java.

 HASH MAP TO TREE MAP

EXPLANATION

2. Copy Elements:

Iterate through the entries of the original HashMap.

Insert each entry (key-value pair) into the TreeMap. The TreeMap's

internal Red-Black Tree structure automatically maintains the

sorted order based on keys.

 HASH MAP TO TREE MAP

EXPLANATION

3. Automatic Ordering:

The TreeMap's sorting mechanism ensures that the entries are stored

in ascending order based on the natural ordering of keys or a

custom comparator if specified.

 HASH MAP TO TREE MAP

PSEUDOCODE

function convertHashMapToTreeMap(hashMap):
// Step 1: Create a TreeMap instance
TreeMap treeMap = new TreeMap()
// Step 2: Copy elements from HashMap to TreeMap
for each entry in hashMap:
key = entry.getKey()
value = entry.getValue()
treeMap.put(key, value)
// Step 3: Return the TreeMap
 FRACTIONAL KNAPSACK PROBLEM
import java.util.HashMap; // Print the TreeMap
import java.util.Map; System.out.println("TreeMap: "
import java.util.TreeMap; + treeMap);
}// Step 3: Algorithm
public class HashMapToTreeMapConverter implementation
{ private static TreeMap<Integer,
public static void main(String[] String>
args) { convertHashMapToTreeMap(Map<Integer,
// Step 1: Create a HashMap String> hashMap) {
Map<Integer, String> hashMap = TreeMap<Integer, String>
new HashMap<>(); treeMap = new TreeMap<>();
hashMap.put(3, "Apple"); for (Map.Entry<Integer,
hashMap.put(1, "Banana"); String> entry : hashMap.entrySet()) {
hashMap.put(2, "Orange"); Integer key =
// Step 2: Convert HashMap to entry.getKey();
TreeMap using the algorithm String value =
TreeMap<Integer, String> entry.getValue();
treeMap = treeMap.put(key, value);
convertHashMapToTreeMap(hashMap); }
return treeMap;
}
}
 HASH MAP TO TREE MAP

EXPLANATION

There are a few ways to convert HashMap to TreeMap in Java:

1. Using Collectors (valid in Java 8 and above)

2. Using vanilla Java

3. Using Guava library

4. Manual conversion
 HASH MAP TO TREE MAP

EXPLANATION

1. Using Vanilla Java (Direct Method)

Pass HashMap instance to the TreeMap constructor OR to putAll()
method.
This will directly create the TreeMap from the HashMap
 HASH MAP TO TREE MAP

ALGORITHM

1.Get the HashMap to be converted:

Accept a HashMap instance as a parameter, which is the original map
that you want to convert to a TreeMap.
2.Create a new TreeMap:
Instantiate a new TreeMap instance. This will be the target TreeMap
that will store the elements in sorted order.
 HASHMAP TO TREEMAP

ALGORITHM

3.Pass the HashMap to putAll() method of TreeMap:

Use the putAll() method of the TreeMap to copy all elements from
the HashMap into the TreeMap. This step automatically leverages the
TreeMap constructor that accepts a Map to create a sorted copy.
4.Return the formed TreeMap:
Return the newly formed TreeMap containing the elements in sorted
order based on their keys.
 HASHMAP TO TREEMAP
import java.util.*;
import java.util.stream.*;
class Main
public static <K, V> Map<K, V> convertToTreeMap(Map<K, V> hashMap)
{
Map<K, V> treeMap = new TreeMap<>();
treeMap.putAll(hashMap);
return treeMap;
}
public static void main(String args[])
{
Map<String, String> hashMap = new HashMap<>();
hashMap.put("1", "Welcome");
hashMap.put("2", "to");
hashMap.put("3", "Coding Class");
System.out.println("Original HashMap: " + hashMap);
Map<String, String> treeMap = convertToTreeMap(hashMap);
System.out.println("TreeMap: " + treeMap);
}
}
 HASH MAP TO TREE MAP

EXPLANATION

Stream.collect()

The Stream.collect() method is part of the Java Stream API and is

used to transform the elements of a stream into a different form.

It takes a Collector as an argument, which specifies how the

elements should be accumulated.

 HASH MAP TO TREE MAP

ALGORITHM

1.Create a new TreeMap

Declare a new TreeMap that will store the entries in sorted
order.

2.Convert HashMap entries to Stream:**

Use the entrySet() method to get the entries from the HashMap.
Convert the set of entries into a Stream.
 HASH MAP TO TREE MAP

ALGORITHM

3.Collect entries into TreeMap

Use the Collectors.toMap collector to collect the entries into a
TreeMap.
The toMap collector takes four parameters:
Map.Entry::getKey specifies the key for each entry.
Map.Entry::getValue specifies the value for each entry.
(oldValue, newValue) -> newValue resolves any potential
conflicts by keeping the new value.
TreeMap::new specifies the type of the resulting map.
 HASH MAP TO TREE MAP

ALGORITHM

4.Return the TreeMap

The resulting TreeMap now contains the entries from the original
HashMap sorted based on keys.
 HASH MAP TO TREE MAP

PSEUDOCODE

function convertToTreeMap(hashMap):

// Step 1: Create a new TreeMap

TreeMap treeMap = new TreeMap()

// Step 2: Convert HashMap entries to Stream

Stream<Entry<K, V>> entryStream = hashMap.entrySet().stream()

 HASH MAP TO TREE MAP

PSEUDOCODE

// Step 3: Collect entries into TreeMap

treeMap = entryStream.collect(
Collectors.toMap(
Entry::getKey,
Entry::getValue,
(oldValue, newValue) -> newValue,
TreeMap::new))
// Step 4: Return the TreeMap
return treeMap
 FRACTIONAL KNAPSACK PROBLEM
import java.util.*; public static void main(String args[]) {
import java.util.stream.*; Map<String, String> hashMap = new
HashMap<>();
class Main { hashMap.put("1", "A");
public static <K, V> Map<K, V> hashMap.put("2", "B");
convertToTreeMap(Map<K, V> hashMap) { hashMap.put("3", "W");
Map<K, V> treeMap = hashMap.put("4", "X");
hashMap.entrySet() hashMap.put("6", "Y");
.stream() hashMap.put("7", "Z");
.collect(Collectors.toMap
( System.out.println("HashMap: " +
hashMap);
Map.Entry::getKey,
Map<String, String> treeMap =
Map.Entry::getValue, convertToTreeMap(hashMap);
(oldValue,
newValue) -> newValue, System.out.println("TreeMap: " +
TreeMap::new treeMap);
) }
); }

return treeMap;
}
 HASH MAP TO TREE MAP

EXPLANATION

Using Guava library

Guava also provides a TreeMap implementation which can be

used to create an empty TreeMap instance.

 HASH MAP TO TREE MAP

ALGORITHM

1.Create a new `TreeMap`:

Declare a new `TreeMap` named `treeMap`.
2.Convert `HashMap` entries to `TreeMap`:
Use the `putAll()` method of the `TreeMap` class to copy all
entries from the `HashMap` to the `treeMap`.
The `TreeMap` will automatically organize the entries based on
the natural ordering of keys (`String` in this case).
 HASH MAP TO TREE MAP

ALGORITHM

3.Return the `TreeMap`:

The resulting `TreeMap` now contains the entries from the
original `HashMap` sorted based on keys.
 HASH MAP TO TREE MAP

PSEUDOCODE

function convertToTreeMap(hashMap):
// Step 1: Create a new TreeMap
TreeMap treeMap = new TreeMap()
// Step 2: Copy all entries from HashMap to TreeMap
treeMap.putAll(hashMap)
// Step 3: Return the TreeMap
return treeMap
 FRACTIONAL KNAPSACK PROBLEM
import java.util.*;
class EthCode {
public static <K extends Comparable<? super K>, V> Map<K, V>
convertToTreeMap(Map<K, V> hashMap) {
Map<K, V> treeMap = new TreeMap<>();
treeMap.putAll(hashMap);
return treeMap;
}
public static void main(String args[]) {
Map<String, String> hashMap = new HashMap<>();
hashMap.put("1", "A");
hashMap.put("2", "B");
hashMap.put("3", "W");
hashMap.put("4", "X");
hashMap.put("6", "Y");
hashMap.put("7", "Z");
System.out.println("HashMap: " + hashMap);
Map<String, String> treeMap = convertToTreeMap(hashMap);
System.out.println("TreeMap: " + treeMap);
}
}
 INTERVIEW QUESTIONS

1. What is a winner tree, and how does it work?

Answer: A winner tree is a binary tree where each internal node

represents the minimum value among its children. It efficiently

identifies the overall winner (minimum) among a set of elements.

The root of the tree holds the ultimate winner.

 INTERVIEW QUESTIONS

2.How is a winner tree different from a loser tree?

Answer: Winner trees find the minimum value, while loser trees

find the maximum. Winner tree nodes represent the winner of their

children, while loser tree nodes represent the loser.

 INTERVIEW QUESTIONS

3. Explain the process of updating a value in a winner tree.

Answer: To update a value in a winner tree:

- Modify the corresponding leaf node.

- Propagate the change to the root, recalculating winners at

each level.
 INTERVIEW QUESTIONS

4.Provide an example use case where a winner tree would be

beneficial.

Answer: Winner trees are useful in ranking scenarios, like sports

tournaments, where you need to quickly identify the best

performer with the lowest score or fastest time.

 INTERVIEW QUESTIONS

5.Are winner trees limited to numeric values, or can they

handle other types of data?

Answer: Winner trees are versatile and can handle various data

types, not limited to numeric values. The comparison criteria

used to determine winners can be adapted for different data

types.
https://learn.codemithra.com
 THANK
YOU

+91 78150 [email protected] www.codemithra.com

95095