feat(SortedMapDemo2): demonstrate TreeMap with custom descending key order

What
- Added SortedMapDemo2 class.
- Created TreeMap with custom Comparator `(a,b) -> b-a` (descending order by keys).
- Inserted keys {91, 99, 78, 77} with values.
- Printed map showing descending order of keys.
- Demonstrated navigation methods in reversed order:
  • firstKey() → highest key
  • lastKey() → lowest key
  • headMap(), tailMap() behavior under descending comparator
- Checked key and value existence with containsKey/containsValue.

Why
- To illustrate how a custom Comparator alters TreeMap’s natural ordering.
- Show differences in semantics of navigation methods when order is reversed.
- Reinforce concept that all range queries follow the comparator, not natural ascending.

How
- Constructed TreeMap with custom comparator.
- Added entries out of order.
- Map sorted internally in descending order: {99=Shubham, 91=Vivek, 78=Mohit, 77=Vipul}.
- Demonstrated:
  • firstKey() = 99 (largest)
  • lastKey() = 77 (smallest)
  • headMap(91) = keys greater than 91 (→ {99=Shubham})
  • tailMap(91) = keys <= 91 (→ {91=Vivek, 78=Mohit, 77=Vipul})
- Key/value checks:
  • containsKey(78) → true
  • containsValue(77) → false (77 is key, not value).

Logic
- Data structure: TreeMap (Red-Black Tree).
- Comparator defines ordering → descending order of integer keys.
- Complexity:
  - put/get/remove = O(log n).
  - headMap/tailMap adapt to custom comparator rules.
- Important:
  - With descending comparator, “first” = greatest element, “last” = smallest.
  - headMap/tailMap follow comparator semantics, not numeric natural meaning.

Real-life applications
- Useful for scenarios like leaderboards, where highest score should appear first.
- Descending order maps for stock prices, high-priority tasks, or ranking systems.
- Great alternative to manual reverse traversals of ascending TreeMaps.

Summary
- Custom Comparator allows TreeMap to order keys in descending order.
- Navigation methods (firstKey, lastKey, headMap, tailMap) adapt to this custom order.
- TreeMap remains O(log n) efficient while supporting ordered views in both directions.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Sorted Map/src/SortedMapDemo2.java

@@ -0,0 +1,38 @@
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+public class SortedMapDemo2 {
+    public static void main(String[] args) {
+        // TreeMap with custom Comparator (descending order by keys)
+        SortedMap<Integer, String> map = new TreeMap<>((a, b) -> b - a);
+
+        map.put(91, "Vivek");
+        map.put(99, "Shubham");
+        map.put(78, "Mohit");
+        map.put(77, "Vipul");
+
+        // Print map -> keys will appear in descending order now
+        System.out.println(map);
+
+        // First (now largest, since descending order)
+        System.out.println("First Key (highest): " + map.firstKey());
+
+        // Last (now smallest, since descending order)
+        System.out.println("Last Key (lowest): " + map.lastKey());
+
+        // headMap(91) -> in descending, gives keys greater than 91
+        System.out.println("headMap(91): " + map.headMap(91));
+
+        // tailMap(91) -> in descending, gives keys <= 91
+        System.out.println("tailMap(91): " + map.tailMap(91));
+
+        // Get by key
+        System.out.println("Value for key 77: " + map.get(77));
+
+        // Key existence
+        System.out.println("Contains key 78? " + map.containsKey(78));
+
+        // Value existence
+        System.out.println("Contains value 77? " + map.containsValue(77));
+    }
+}