From 51352619a1e945ff78d023d8562887f099f5912e Mon Sep 17 00:00:00 2001 From: Lnguyen135 Date: Sat, 7 Mar 2026 17:24:35 -0500 Subject: [PATCH] learn all collections in java --- .../Practice/CollectionBasics.java | 30 +++- .../Practice/CommonMethodsDemo.java | 36 +++- .../java/Collections/Quiz/KnowledgeCheck.md | 20 +-- src/main/java/Collections/README.md | 31 ++++ .../CollectionsHackerrankProblems.java | 167 ++++++++++++++++-- src/main/java/Hierachy/PRACTICE.md | 120 +++++++++++-- .../Challenges/CustomIterableMini.java | 40 ++++- .../Iterable/Examples/ForEachLoopDemo.java | 10 +- .../java/Iterable/Examples/IteratorDemo.java | 16 +- .../Iterable/Practice/IterableWarmups.java | 19 ++ src/main/java/Iterable/README.md | 76 ++++++++ .../Lists/ArrayLists/ArrayListProblems.java | 49 +++-- src/main/java/Lists/ArrayLists/README.md | 130 +++++++++++++- .../Lists/LinkedLists/LinkedListProblems.java | 22 ++- src/main/java/Lists/LinkedLists/README.md | 60 +++++++ src/main/java/Lists/Read.md | 34 ++++ src/main/java/Lists/Vector/README.md | 74 +++++++- .../java/Maps/HashMap/HashMapProblems.java | 16 +- src/main/java/Maps/HashMap/README.md | 51 ++++++ .../LinkedHashMap/LinkedHashMapProblems.java | 81 +++++++-- src/main/java/Maps/LinkedHashMap/README.md | 73 ++++++++ src/main/java/Maps/MapBasics/README.md | 56 ++++++ src/main/java/Maps/README.md | 50 ++++++ .../java/Maps/TreeMap/TreeMapProblems.java | 67 +++++-- .../Queues/ArrayDeque/ArrayDequeProblems.java | 20 ++- src/main/java/Queues/ArrayDeque/README.md | 64 +++++++ src/main/java/Queues/Deque/DequeProblems.java | 67 +++++-- src/main/java/Queues/Deque/README.md | 67 ++++++- src/main/java/Queues/PriorityQueue/README.md | 83 +++++++++ src/main/java/Queues/Queue/README.md | 104 +++++++++++ .../java/Sets/HashSet/HashSetProblems.java | 11 +- src/main/java/Sets/HashSet/README.md | 57 +++++- src/main/java/Sets/LinkedHashSet/README.md | 52 ++++++ src/main/java/Sets/TreeSet/README.md | 73 ++++++++ src/main/java/Stack.java | 67 ++++++- 35 files changed, 1850 insertions(+), 143 deletions(-) diff --git a/src/main/java/Collections/Practice/CollectionBasics.java b/src/main/java/Collections/Practice/CollectionBasics.java index e45cb49..16aaed1 100644 --- a/src/main/java/Collections/Practice/CollectionBasics.java +++ b/src/main/java/Collections/Practice/CollectionBasics.java @@ -33,6 +33,9 @@ public static int sum(Collection numbers) { // TODO: // Loop through the collection // Add each number to total + for(Integer s : numbers){ + total +=s; + } return total; } @@ -49,6 +52,11 @@ public static int countEven(Collection numbers) { // TODO: // Loop through the collection // If the number is even, increase count + for(Integer ce : numbers) { + if(ce %2==0){ + count++; + } + } return count; } @@ -65,6 +73,11 @@ public static int findMax(Collection numbers) { // TODO: // Loop through numbers // Update max if current number is larger + for(Integer fm :numbers){ + if(fm>max){ + max=fm; + } + } return max; } @@ -80,7 +93,12 @@ public static boolean hasDuplicates(Collection numbers) { // TODO: // Hint: // Compare the size of a collection with the size of a Set - +Set see = new HasSet<>(); +for(Integer n: see){ + if(see.contains(n)){ + return true; + }see.add(n); +} return false; } @@ -96,6 +114,11 @@ public static int countOccurrences(Collection numbers, int target) { // TODO: // Loop through numbers // If number equals target, increase count + for(Integer a : numbers){ + if(a.equals(target)){ + count++ + } + } return count; } @@ -113,6 +136,11 @@ public static Collection filterGreaterThanTwenty(Collection nu // TODO: // Loop through numbers // Add numbers greater than 20 to result + for(Integer b : result){ + if(b>20){ + result.add(b); + } + } return result; } diff --git a/src/main/java/Collections/Practice/CommonMethodsDemo.java b/src/main/java/Collections/Practice/CommonMethodsDemo.java index b2dd6f9..c7239f7 100644 --- a/src/main/java/Collections/Practice/CommonMethodsDemo.java +++ b/src/main/java/Collections/Practice/CommonMethodsDemo.java @@ -131,6 +131,14 @@ public static void main(String[] args) { Add the following values: 10, 20, 30, 40, 50 */ +Collections numbers = new ArrayList<>(); + numbers.add(10); + numbers.add(20); + numbers.add(30); + numbers.add(40); + numbers.add(50); + + // num.addAll(numbers); /* @@ -138,18 +146,18 @@ public static void main(String[] args) { Print the size of the numbers collection */ - + System.out.println(numbers.size()); /* TODO 3: Check if the collection contains 30 */ - +boolean hasNum= numbers.contains(30); /* TODO 4: Remove the number 20 */ - +int newNum = numbers.remove(20); /* TODO 5: @@ -157,13 +165,33 @@ public static void main(String[] args) { and print each value */ - +for(int n:numbers){ + System.out.println(n); +} /* REFLECTION QUESTIONS: 1. Why can we use Collection as the reference type? + Because ArrayList implements the Collection interface. + ArrayList is a class that implements List, and List extends Collection. +So an ArrayList is a type of Collection, which allows us to store it in a Collection reference. + 2. What methods are available because of the Collection interface? + add() + remove() + contains() + size() + isEmpty() + clear() + iterator() 3. What methods are NOT available when using Collection instead of List? + Methods that belong only to List are not available when the reference type is Collection. +Examples of List-only methods: +get(index) +set(index, element) +add(index, element) +remove(index) +indexOf() */ } diff --git a/src/main/java/Collections/Quiz/KnowledgeCheck.md b/src/main/java/Collections/Quiz/KnowledgeCheck.md index 43ee11f..1f0d098 100644 --- a/src/main/java/Collections/Quiz/KnowledgeCheck.md +++ b/src/main/java/Collections/Quiz/KnowledgeCheck.md @@ -16,7 +16,7 @@ A. `Collection` is a class B. `Collection` extends `List` C. `Collection` is the root interface for most collection types D. `Collection` only stores key-value pairs - +Answer : C --- ## Question 2 @@ -36,7 +36,7 @@ A. 0 B. 1 C. 3 D. 30 - +Answer: C --- ## Question 3 @@ -47,7 +47,7 @@ A. `search()` B. `exists()` C. `contains()` D. `check()` - +Answer: C --- ## Question 4 @@ -69,7 +69,7 @@ A. `[Alex, Jordan]` B. `[Jordan]` C. `[Alex]` D. `[]` - +Answer: B --- ## Question 5 @@ -80,7 +80,7 @@ A. `add()` B. `addAll()` C. `insertAll()` D. `merge()` - +Answer: B --- ## Question 6 @@ -97,7 +97,7 @@ A. `true` B. `false` C. `0` D. Compilation error - +Answer: A --- ## Question 7 @@ -108,7 +108,7 @@ A. `removeAll()` B. `deleteAll()` C. `clear()` D. `reset()` - +Answer: A --- ## Question 8 @@ -131,7 +131,7 @@ A. `5 10 15` B. `15 10 5` C. `0 1 2` D. Compilation error - +Answer: A --- ## Question 9 @@ -142,7 +142,7 @@ A. Elements can be added B. Elements can be removed C. Indexed access using `.get(index)` D. Elements can be iterated using a loop - +Answer: C --- ## Question 10 @@ -157,6 +157,6 @@ A. It automatically sorts the collection B. It prevents duplicates C. It allows flexibility to change implementations later D. It forces the collection to be synchronized - +Answer: C ``` ``` diff --git a/src/main/java/Collections/README.md b/src/main/java/Collections/README.md index a3dfc4f..bc430f2 100644 --- a/src/main/java/Collections/README.md +++ b/src/main/java/Collections/README.md @@ -117,10 +117,41 @@ You can switch to `HashSet` or `LinkedList` later without changing much code. ## Practice Ideas * Write a method that accepts `Collection` and returns the sum + import java.util.Collection; + +public static int sumCollection (Collection numbers) { +int sum = 0; + + for (int num : numbers) { + sum += num; + } + + return sum; +} + * Find intersection of two collections + +Collection intersection(Collection a, Collectionb){ +Collection result = new ArrayList<>>(); +for(Integer i:a){ +if(b.contains(i)){ +result.add(i); +} +} +return(result); +} + + * Remove duplicates using a Set + +public static Collection removeDuplicate (Collection numbers){ +return new HasSet<>(numbers); +} + * Determine if one collection is a subset of another +public static boolean isSubset(Collection a, Collection b ){ +return b.containsAll(a); --- ## Summary diff --git a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java index 6c2f4e1..8f25b51 100644 --- a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java +++ b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java @@ -24,8 +24,11 @@ public static void main(String[] args) { public static List removeDuplicates(List numbers) { // TODO: Implement this method +// Use LinkedHashSet to remove duplicates and keep order + Set unique = new LinkedHashSet<>(numbers); - return null; + // Convert back to List + return new ArrayList<>(unique); } /* @@ -39,8 +42,19 @@ public static List removeDuplicates(List numbers) { public static Map countFrequency(List numbers) { // TODO: Implement this method - - return null; +//Create a HashMap to store counts. +//Loop through the list. +//getOrDefault(num, 0): +//If the number is not in the map → return 0 +//If it exists → return the current count +//Add 1 to update the count. + Map frequencyMap = new HashMap<>(); + + for (Integer num : numbers) { + frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); + } + + return frequencyMap; } /* @@ -54,8 +68,26 @@ public static Map countFrequency(List numbers) { public static Integer firstUnique(List numbers) { // TODO: Implement this method - - return null; + //Use LinkedHashMap to store counts while keeping order. + //First loop → count occurrences. + //Second loop → return the first key whose value is 1. + Map map = new LinkedHashMap<>(); + //List input = Arrays.asList(4,5,1,2,0,4); + //System.out.println(firstUnique(input)); + // Count frequency + for (Integer num : numbers) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + + // Find first number with count = 1 + for (Map.Entry entry : map.entrySet()) { + if (entry.getValue() == 1) { + return entry.getKey(); + } + } + + return null; // if no unique number exists + } } /* @@ -71,10 +103,23 @@ public static Integer firstUnique(List numbers) { public static boolean twoSum(List numbers, int target) { // TODO: Implement this method + //Check if the complement already appeared in the list. + //If yes → the two numbers add up to the target → return true. + //Otherwise add the current number to the set and continue. + Set seen = new HashSet<>(); + + for (Integer num : numbers) { + int complement = target - num; + + if (seen.contains(complement)) { + return true; + } + + seen.add(num); + } return false; } - /* Problem 5 Count how many unique words exist in a list. @@ -87,7 +132,9 @@ public static int countUniqueWords(List words) { // TODO: Implement this method - return 0; + Set uniqueWords = new HashSet<>(words); + + return uniqueWords.size(); } /* @@ -101,10 +148,27 @@ public static int countUniqueWords(List words) { public static Queue reverseQueue(Queue queue) { // TODO: Implement this method - - return null; +// Queue → Stack +//poll() removes elements from the queue. +//push() adds them to the stack. +//Stack → Queue +//pop() removes from stack (last-in-first-out). +//offer() adds back to queue. +//This reverses the order. + Stack stack = new Stack<>(); + + // Move elements from queue to stack + while (!queue.isEmpty()) { + stack.push(queue.poll()); + } + + // Move elements back to queue (reversed order) + while (!stack.isEmpty()) { + queue.offer(stack.pop()); + } + + return queue; } - /* Problem 7 Determine whether parentheses are balanced. @@ -119,11 +183,29 @@ public static Queue reverseQueue(Queue queue) { public static boolean isBalanced(String expression) { // TODO: Implement this method - - return false; +//use a Stack. +//A stack works well because we must match every opening ( with a closing ) in the correct order. + Stack stack = new Stack<>(); + + for (char ch : expression.toCharArray()) { + + if (ch == '(') { + stack.push(ch); // store opening parenthesis + } + + else if (ch == ')') { + if (stack.isEmpty()) { + return false; // no matching opening + } + stack.pop(); // match found + } + } + + // if stack is empty, parentheses are balanced + return stack.isEmpty(); } - /* + /* Problem 8 Return the number that appears most frequently in the list. @@ -134,10 +216,27 @@ public static boolean isBalanced(String expression) { public static Integer mostFrequent(List numbers) { // TODO: Implement this method - - return null; +//use a Map to count occurrences, then track the number with the highest count. + Map map = new HashMap<>(); + + // Count frequencies + for (Integer num : numbers) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + + Integer mostFrequent = null; + int maxCount = 0; + + // Find the number with highest frequency + for (Map.Entry entry : map.entrySet()) { + if (entry.getValue() > maxCount) { + maxCount = entry.getValue(); + mostFrequent = entry.getKey(); + } + } + + return mostFrequent; } - /* Problem 9 Group words based on their length. @@ -155,7 +254,19 @@ public static Map> groupByLength(List words) { // TODO: Implement this method - return null; + Map> map = new HashMap<>(); + + for (String word : words) { + int length = word.length(); + + if (!map.containsKey(length)) { + map.put(length, new ArrayList<>()); + } + + map.get(length).add(word); + } + + return map; } /* @@ -169,10 +280,28 @@ public static Map> groupByLength(List words) { Output: 9 */ public static int maxSlidingWindowSum(List numbers, int k) { - +//using the Sliding Window technique so we don’t repeatedly sum the same elements. // TODO: Implement this method - return 0; + int windowSum = 0; + int maxSum = 0; + + // First window + for (int i = 0; i < k; i++) { + windowSum += numbers.get(i); + } + + maxSum = windowSum; + + // Slide the window + for (int i = k; i < numbers.size(); i++) { + windowSum += numbers.get(i); // add next element + windowSum -= numbers.get(i - k); // remove element leaving window + + maxSum = Math.max(maxSum, windowSum); + } + + return maxSum; } } } diff --git a/src/main/java/Hierachy/PRACTICE.md b/src/main/java/Hierachy/PRACTICE.md index 2b885d9..f3942f6 100644 --- a/src/main/java/Hierachy/PRACTICE.md +++ b/src/main/java/Hierachy/PRACTICE.md @@ -15,7 +15,7 @@ A. Collection B. Iterable C. List D. Queue - +Answer : B --- ## Question 2 @@ -26,7 +26,7 @@ A. Iterable B. Collection C. Map D. Deque - +Answer: B --- ## Question 3 @@ -37,7 +37,7 @@ A. List B. Set C. Queue D. Map - +Answer: D --- ## Question 4 @@ -48,7 +48,7 @@ A. Set B. List C. Queue D. TreeSet - +Answer: B --- ## Question 5 @@ -59,18 +59,18 @@ A. List B. Set C. Queue D. Map - +Answer: D --- # True or False Write **True** or **False**. -1. `ArrayList` implements the `List` interface. -2. `Set` allows duplicate elements. -3. `Map` stores elements using keys and values. -4. `Queue` typically follows FIFO behavior. -5. `Iterable` allows collections to be used in enhanced for-loops. +1. `ArrayList` implements the `List` interface. True +2. `Set` allows duplicate elements. False +3. `Map` stores elements using keys and values. True +4. `Queue` typically follows FIFO behavior. True +5. `Iterable` allows collections to be used in enhanced for-loops.True --- @@ -79,13 +79,14 @@ Write **True** or **False**. ## Question 1 What is the difference between an **interface** and a **class** in the Java Collections Framework? - +Interfaces define behavior. +Classes implement those behaviors. --- ## Question 2 Why is it recommended to declare variables using interfaces like `List` instead of concrete classes like `ArrayList`? - +Because it provides flexibility, abstraction, and better code design Example: ```java @@ -97,7 +98,7 @@ List list = new ArrayList<>(); ## Question 3 Name three interfaces that extend `Collection`. - +List, Set & Queue --- # Code Reading Exercise @@ -117,9 +118,9 @@ for (String fruit : fruits) { Questions: -1. Which interface type is used for the variable? -2. Which class is used as the implementation? -3. Why can the enhanced for-loop be used here? +1. Which interface type is used for the variable? List +2. Which class is used as the implementation? ArrayList +3. Why can the enhanced for-loop be used here? List extend Collections which extends Iterable --- @@ -132,9 +133,47 @@ Create a small program that demonstrates the following: 3. A **Queue** that stores three tasks. 4. A **Map** that stores student names and grades. -Print the contents of each structure. +import java.util.*; + +public class CollectionsDemo { +public static void main(String[] args) { + + // 1. List of three names + List names = new ArrayList<>(); + names.add("Alice"); + names.add("Bob"); + names.add("Charlie"); + System.out.println("List of names: " + names); + + // 2. Set of unique numbers + Set numbers = new HashSet<>(); + numbers.add(10); + numbers.add(20); + numbers.add(10); // duplicate ignored + System.out.println("Set of unique numbers: " + numbers); + + // 3. Queue of three tasks + Queue tasks = new LinkedList<>(); + tasks.offer("Task 1"); + tasks.offer("Task 2"); + tasks.offer("Task 3"); + System.out.println("Queue of tasks: " + tasks); + + // 4. Map of student names and grades + Map studentGrades = new HashMap<>(); + studentGrades.put("Alice", 90); + studentGrades.put("Bob", 85); + studentGrades.put("Charlie", 95); + System.out.println("Map of student grades: " + studentGrades); + } +} +//Print the contents of each structure. ---- +List of names: [Alice, Bob, Charlie] +Set of unique numbers: [20, 10] // order may vary +Queue of tasks: [Task 1, Task 2, Task 3] +Map of student grades: {Alice=90, Bob=85, Charlie=95} // order may vary +---------- # Challenge Exercise @@ -150,6 +189,49 @@ Then: * Print each structure * Add one new element to each structure * Print them again - + import java.util.*; + +public class CollectionsExercise { +public static void main(String[] args) { + + // 1. List of student names + List students = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie")); + System.out.println("Initial List of students: " + students); + + // Add a new student + students.add("David"); + System.out.println("List after adding a student: " + students); + System.out.println(); + + // 2. Set of unique course names + Set courses = new HashSet<>(Arrays.asList("Math", "Science", "History")); + System.out.println("Initial Set of courses: " + courses); + + // Add a new course + courses.add("English"); + System.out.println("Set after adding a course: " + courses); + System.out.println(); + + // 3. Queue of tasks + Queue tasks = new LinkedList<>(Arrays.asList("Homework", "Project", "Study")); + System.out.println("Initial Queue of tasks: " + tasks); + + // Add a new task + tasks.offer("Review"); + System.out.println("Queue after adding a task: " + tasks); + System.out.println(); + + // 4. Map of student → grade + Map studentGrades = new HashMap<>(); + studentGrades.put("Alice", 90); + studentGrades.put("Bob", 85); + studentGrades.put("Charlie", 95); + System.out.println("Initial Map of student grades: " + studentGrades); + + // Add a new student and grade + studentGrades.put("David", 88); + System.out.println("Map after adding a student: " + studentGrades); + } +} ``` ``` diff --git a/src/main/java/Iterable/Challenges/CustomIterableMini.java b/src/main/java/Iterable/Challenges/CustomIterableMini.java index ce2516a..9d1c2b0 100644 --- a/src/main/java/Iterable/Challenges/CustomIterableMini.java +++ b/src/main/java/Iterable/Challenges/CustomIterableMini.java @@ -1,4 +1,40 @@ package Iterable.Challenges; -public class CustomIterableMini { -} + +import java.util.Iterator; + +public class CustomIterableMini implements Iterable { + + private int limit; + + public CustomIterableMini(int limit) { + this.limit = limit; + } + + @Override + public Iterator iterator() { + return new Iterator<>() { + private int current = 0; + + @Override + public boolean hasNext() { + return current <= limit; + } + + @Override + public Integer next() { + int value = current; + current += 2; // move to next even number + return value; + } + }; + } + + // Simple test + public static void main(String[] args) { + CustomIterableMini evens = new CustomIterableMini(10); + for (int n : evens) { + System.out.print(n + " "); // Output: 0 2 4 6 8 10 + } + } +} \ No newline at end of file diff --git a/src/main/java/Iterable/Examples/ForEachLoopDemo.java b/src/main/java/Iterable/Examples/ForEachLoopDemo.java index a6d2198..a7ac75f 100644 --- a/src/main/java/Iterable/Examples/ForEachLoopDemo.java +++ b/src/main/java/Iterable/Examples/ForEachLoopDemo.java @@ -17,13 +17,16 @@ public static void main(String[] args) { // TODO: // Use a for-each loop to print each student name - +for(String n:students){ + System.out.println(n); +} System.out.println("\nPrinting students in uppercase:"); // TODO: // Use a for-each loop to print each name in uppercase - + for(String n:students){ + System.out.println(n.toUpperCase()). System.out.println("\nCount the number of students:"); @@ -31,6 +34,9 @@ public static void main(String[] args) { // TODO: // Use a for-each loop to count how many students are in the list + for(String n:students){ + count +=n; + } System.out.println("Total students: " + count); } diff --git a/src/main/java/Iterable/Examples/IteratorDemo.java b/src/main/java/Iterable/Examples/IteratorDemo.java index b09fca7..276afe0 100644 --- a/src/main/java/Iterable/Examples/IteratorDemo.java +++ b/src/main/java/Iterable/Examples/IteratorDemo.java @@ -21,11 +21,15 @@ public static void main(String[] args) { // Create iterator Iterator iterator = numbers.iterator(); - System.out.println("\nIterating using Iterator:"); + System.out.println("\nIterating using Iterator:" + iterator); // TODO: // Use iterator.hasNext() and iterator.next() // Print each number + while (iterator.hasNext()) { + Integer num = iterator.next(); + System.out.println(num); + } System.out.println("\nRemoving odd numbers using Iterator"); @@ -36,8 +40,14 @@ public static void main(String[] args) { // Use iterator to remove odd numbers // Remember: use iterator.remove() + while (iterator.hasNext()) { + Integer num = iterator.next(); + if (num % 2 != 0) { + iterator.remove(); // safely remove odd numbers + } + } - System.out.println("\nUpdated list:"); + System.out.println("\nUpdated list (no odd numbers):"); System.out.println(numbers); } -} +} \ No newline at end of file diff --git a/src/main/java/Iterable/Practice/IterableWarmups.java b/src/main/java/Iterable/Practice/IterableWarmups.java index 9e9de94..ba579a5 100644 --- a/src/main/java/Iterable/Practice/IterableWarmups.java +++ b/src/main/java/Iterable/Practice/IterableWarmups.java @@ -30,6 +30,9 @@ public static int sum(Iterable numbers) { // TODO: // Use a for-each loop to calculate the sum + for(int s :numbers){ + total +=s; + } return total; } @@ -46,6 +49,11 @@ public static int countEven(Iterable numbers) { // TODO: // Loop through numbers // Increment count if number is even + for(int e: numbers){ + if(e%2== 0){ + count ++; + } + } return count; } @@ -62,6 +70,12 @@ public static int findMax(Iterable numbers) { // TODO: // Loop through numbers // Update max if current number is larger + for(int m: numbers){ + if(m>max){ + max= m; + } + + } return max; } @@ -78,6 +92,11 @@ public static int countMatches(Iterable words, String target) { // TODO: // Loop through words // Compare each word to target + for(String ma: words){ + if(ma.equal(target)){ + count ++; + } + } return count; } diff --git a/src/main/java/Iterable/README.md b/src/main/java/Iterable/README.md index 858f7e3..570124c 100644 --- a/src/main/java/Iterable/README.md +++ b/src/main/java/Iterable/README.md @@ -156,10 +156,86 @@ for (int n : box) { ## Practice Ideas * Write a method that accepts `Iterable` and returns the sum + +public static int sumIterable(Iterable numbers) { +int sum = 0; +for (Integer num : numbers) { +sum += num; +} +return sum; +} + +// Example usage: +List nums = Arrays.asList(1, 2, 3, 4); +System.out.println("Sum: " + sumIterable(nums)); // Output: 10 + * Remove all odd numbers using `Iterator` + +import java.util.*; + +List numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); +Iterator iter = numbers.iterator(); + +while (iter.hasNext()) { +if (iter.next() % 2 != 0) { +iter.remove(); // remove odd numbers safely +} +} + +System.out.println(numbers); // Output: [2, 4] + * Count elements greater than a value + +public static int countGreaterThan(Iterable numbers, int threshold) { +int count = 0; +for (Integer num : numbers) { +if (num > threshold) { +count++; +} +} +return count; +} + +// Example usage: +List nums = Arrays.asList(1, 5, 3, 7, 2); +System.out.println("Count > 3: " + countGreaterThan(nums, 3)); // Output: 2 + * Create a simple custom class that implements `Iterable` +import java.util.Iterator; + +class EvenNumbers implements Iterable { +private int limit; + + public EvenNumbers(int limit) { + this.limit = limit; + } + + @Override + public Iterator iterator() { + return new Iterator<>() { + private int current = 0; + + @Override + public boolean hasNext() { + return current <= limit; + } + + @Override + public Integer next() { + int value = current; + current += 2; + return value; + } + }; + } +} + +// Example usage: +EvenNumbers evens = new EvenNumbers(10); +for (int n : evens) { +System.out.print(n + " "); // Output: 0 2 4 6 8 10 +} --- ## Summary diff --git a/src/main/java/Lists/ArrayLists/ArrayListProblems.java b/src/main/java/Lists/ArrayLists/ArrayListProblems.java index baf4dfa..21d2670 100644 --- a/src/main/java/Lists/ArrayLists/ArrayListProblems.java +++ b/src/main/java/Lists/ArrayLists/ArrayListProblems.java @@ -34,9 +34,18 @@ public static void main(String[] args) { public static int sum(List nums) { // TODO: Implement this method + public static int sum(List nums) { + + int total = 0; + + for (int num : nums) { + total += num; + } + + return total; + } + - return 0; - } /* Problem 2 @@ -49,8 +58,13 @@ public static int sum(List nums) { public static int countEvens(List nums) { // TODO: Implement this method - - return 0; + int count =0; +for(int n:nums){ + if(n%2==0){ +count ++; + } +} + return count; } /* @@ -81,10 +95,18 @@ public static boolean hasDuplicate(List nums) { */ public static int findMax(List nums) { - // TODO: Implement this method + Set seen = new HashSet<>(); + + for (int n : nums) { + if (seen.contains(n)) { + return true; + } + seen.add(n); + } + + return false; + } - return 0; - } /* Problem 5 @@ -96,10 +118,13 @@ public static int findMax(List nums) { The original list should remain unchanged. */ - public static List reverse(List nums) { + public static List reverse(List nums) { - // TODO: Implement this method + List reversed = new ArrayList<>(); - return null; - } -} + for (int i = nums.size() - 1; i >= 0; i--) { + reversed.add(nums.get(i)); + } + + return reversed; + } diff --git a/src/main/java/Lists/ArrayLists/README.md b/src/main/java/Lists/ArrayLists/README.md index 7102e57..eb2c209 100644 --- a/src/main/java/Lists/ArrayLists/README.md +++ b/src/main/java/Lists/ArrayLists/README.md @@ -21,7 +21,7 @@ List names = new ArrayList<>(); --- ## Where It Fits - + ``` Iterable → Collection → List → ArrayList ``` @@ -111,11 +111,139 @@ Avoid it when: ## Practice Ideas * Reverse a list + +public static List reverseList(List() list){ +Collectios.reserse(list); +return list; +} + * Remove duplicates + +public static List removeDuplicate(List() numbers){ +return new ArrayList<>(new HasSet<>(numbers)); + + * Rotate list by k + +public class RotateList { +public static void main(String[] args) { +List list = new ArrayList<>(Arrays.asList(1,2,3,4,5)); +int k = 2; + + Collections.rotate(list, k); + + System.out.println(list); + } +} +----------or: +import java.util.*; + +public class RotateListManual { + + public static void rotate(List list, int k) { + int n = list.size(); + k = k % n; + + List temp = new ArrayList<>(); + + temp.addAll(list.subList(n - k, n)); + temp.addAll(list.subList(0, n - k)); + + for(int i=0;i list = new ArrayList<>(Arrays.asList(1,2,3,4,5)); + + rotate(list,2); + + System.out.println(list); + } +} * Find second largest number + import java.util.*; + +public class SecondLargest { + + public static void main(String[] args) { + + List list = new ArrayList<>(Arrays.asList(10,20,4,45,99)); + + Collections.sort(list); + + int secondLargest = list.get(list.size()-2); + + System.out.println("Second Largest: " + secondLargest); + } +} +---------or: +import java.util.*; + +public class SecondLargestBetter { + + public static int findSecondLargest(List list){ + + int largest = Integer.MIN_VALUE; + int second = Integer.MIN_VALUE; + + for(int num : list){ + + if(num > largest){ + second = largest; + largest = num; + } + else if(num > second && num != largest){ + second = num; + } + } + + return second; + } + + public static void main(String[] args) { + + List list = Arrays.asList(10,20,4,45,99); + + System.out.println(findSecondLargest(list)); + } +} + * Two-sum problem + import java.util.*; + +public class TwoSum { + public static int[] twoSum(List nums, int target){ + + Map map = new HashMap<>(); + + for(int i=0;i nums = Arrays.asList(2,7,11,15); + + int target = 9; + + int[] result = twoSum(nums,target); + + System.out.println(result[0] + " " + result[1]); + } +} --- ### Summary diff --git a/src/main/java/Lists/LinkedLists/LinkedListProblems.java b/src/main/java/Lists/LinkedLists/LinkedListProblems.java index 178a2ba..72f2877 100644 --- a/src/main/java/Lists/LinkedLists/LinkedListProblems.java +++ b/src/main/java/Lists/LinkedLists/LinkedListProblems.java @@ -38,7 +38,7 @@ public static void main(String[] args) { public static void addToFront(LinkedList list, int value) { // TODO: Implement this method - + list.addFirst(value); } /* @@ -52,7 +52,7 @@ public static void addToFront(LinkedList list, int value) { public static void addToEnd(LinkedList list, int value) { // TODO: Implement this method - + list.addLast(value); } /* @@ -66,7 +66,9 @@ public static void addToEnd(LinkedList list, int value) { public static void removeFirstElement(LinkedList list) { // TODO: Implement this method - + if (!list.isEmpty()) { // always check to avoid NoSuchElementException + list.removeFirst(); + } } /* @@ -80,9 +82,10 @@ public static void removeFirstElement(LinkedList list) { public static void removeLastElement(LinkedList list) { // TODO: Implement this method - + if (!list.isEmpty()) { // check to avoid NoSuchElementException + list.removeLast(); + } } - /* Problem 5 Return the FIRST element in the LinkedList. @@ -95,9 +98,11 @@ public static int getFirstElement(LinkedList list) { // TODO: Implement this method - return 0; + if (!list.isEmpty()) { + return list.getFirst(); + } + throw new NoSuchElementException("The list is empty."); } - /* Problem 6 Return the LAST element in the LinkedList. @@ -110,6 +115,5 @@ public static int getLastElement(LinkedList list) { // TODO: Implement this method - return 0; - } + return list.getLast(); } diff --git a/src/main/java/Lists/LinkedLists/README.md b/src/main/java/Lists/LinkedLists/README.md index bca958d..0fa79c4 100644 --- a/src/main/java/Lists/LinkedLists/README.md +++ b/src/main/java/Lists/LinkedLists/README.md @@ -158,11 +158,71 @@ Avoid it when: ## Practice Ideas * Implement a queue using LinkedList +// LinkedList naturally supports FIFO, so you can use offer() to enqueue and poll() to dequeue. +LinkedList queue = new LinkedList<>(); + +// Enqueue +queue.offer("Task1"); +queue.offer("Task2"); + +// Dequeue +System.out.println(queue.poll()); // Task1 +System.out.println(queue.poll()); // Task2 + * Implement a stack using LinkedList +//LinkedList can also act as a stack (LIFO) using push() and pop(). +LinkedList stack = new LinkedList<>(); + +stack.push(10); +stack.push(20); +stack.push(30); + +System.out.println(stack.pop()); // 30 +System.out.println(stack.pop()); // 20 + * Remove duplicates manually + +LinkedList list = new LinkedList<>(Arrays.asList(1,2,2,3,3,3,4)); +for (int i = 0; i < list.size(); i++) { +for (int j = i + 1; j < list.size(); j++) { +if (list.get(i).equals(list.get(j))) { +list.remove(j); +j--; // adjust index after removal +} +} +} +System.out.println(list); // [1, 2, 3, 4] + * Insert element after every occurrence of X + +LinkedList list = new LinkedList<>(Arrays.asList(1,2,3,2,4)); +int X = 2; +int valueToInsert = 99; + +ListIterator iter = list.listIterator(); +while (iter.hasNext()) { +if (iter.next() == X) { +iter.add(valueToInsert); +} +} +System.out.println(list); // [1, 2, 99, 3, 2, 99, 4] + * Simulate browser history navigation +LinkedList history = new LinkedList<>(); +history.add("google.com"); +history.add("stackoverflow.com"); +history.add("github.com"); + +int currentIndex = history.size() - 1; // last visited page + +// Back +if (currentIndex > 0) currentIndex--; +System.out.println(history.get(currentIndex)); // stackoverflow.com + +// Forward +if (currentIndex < history.size() - 1) currentIndex++; +System.out.println(history.get(currentIndex)); // github.com --- ## Summary diff --git a/src/main/java/Lists/Read.md b/src/main/java/Lists/Read.md index 966e642..ec70745 100644 --- a/src/main/java/Lists/Read.md +++ b/src/main/java/Lists/Read.md @@ -181,9 +181,43 @@ Banana ## Practice Ideas * Reverse a list + +public static List reverseList(List list){ +Collections.reserse(list); +return list; + +-------or: +public static List reverseList list){ + +Collection result = new ArrayList<>(); +for( int x = list.size()-1; x>=0; x--){ +return result.list.get(x); +} + + * Find the second largest number + +public static int findSecondLargestNum(List() numbers){ +Set unique = new HasSet<>(numbers); +List list= new ArrayList<>(unique); +Collections.sort(list); +resul.get(list.size()-2); +} + + + * Remove duplicates from a list + +public static List removeDuplicate(List<>() numbers){ +return new ArrayList<>(new HasSet<>(numbers)); +) * Merge two lists +* +public static List mergeTwoLists(List a, List b){ +List result = new ArrayList<>(a); +result.AddAll(b); +return result; +} --- diff --git a/src/main/java/Lists/Vector/README.md b/src/main/java/Lists/Vector/README.md index 4f140e4..9cc5f44 100644 --- a/src/main/java/Lists/Vector/README.md +++ b/src/main/java/Lists/Vector/README.md @@ -130,9 +130,81 @@ Avoid it when: ## Practice Ideas * Compare performance of `Vector` vs `ArrayList` +//Vector is synchronized, so every operation has thread-safety overhead. + // ArrayList is unsynchronized, so it’s faster in single-threaded + +import java.util.*; + +public class VectorVsArrayList { +public static void main(String[] args) { +int n = 1_000_000; + + Vector vector = new Vector<>(); + ArrayList arrayList = new ArrayList<>(); + + // Measure Vector + long start = System.currentTimeMillis(); + for (int i = 0; i < n; i++) vector.add(i); + long end = System.currentTimeMillis(); + System.out.println("Vector time: " + (end - start) + " ms"); + + // Measure ArrayList + start = System.currentTimeMillis(); + for (int i = 0; i < n; i++) arrayList.add(i); + end = System.currentTimeMillis(); + System.out.println("ArrayList time: " + (end - start) + " ms"); + } +} * Convert legacy `Vector` code to `ArrayList` -* Simulate multi-threaded access (advanced) +Legacy code may use Vector for storing elements: +Vector vec = new Vector<>(); +vec.add("Alice"); +vec.add("Bob"); +Convert to modern ArrayList: +List list = new ArrayList<>(); +list.add("Alice"); +list.add("Bob"); + +* Simulate multi-threaded access (advanced) +//Vector is synchronized automatically. +// ArrayList is not thread-safe, so concurrent access can cause issues. + +import java.util.*; +import java.util.concurrent.*; + +public class MultiThreadDemo { +public static void main(String[] args) throws InterruptedException { +List vector = new Vector<>(); +List arrayList = new ArrayList<>(); +int n = 1000; + + Runnable taskVector = () -> { + for (int i = 0; i < n; i++) vector.add(i); + }; + + Runnable taskArrayList = () -> { + for (int i = 0; i < n; i++) arrayList.add(i); + }; + + // Vector threads + Thread t1 = new Thread(taskVector); + Thread t2 = new Thread(taskVector); + t1.start(); t2.start(); + t1.join(); t2.join(); + System.out.println("Vector size: " + vector.size()); // usually 2000, safe + + // ArrayList threads (unsafe) + t1 = new Thread(taskArrayList); + t2 = new Thread(taskArrayList); + t1.start(); t2.start(); + t1.join(); t2.join(); + System.out.println("ArrayList size: " + arrayList.size()); // may be < 2000, race condition + } +} +//Vector handles thread safety automatically. +//ArrayList requires external synchronization +//(e.g., Collections.synchronizedList) for safe concurrent access. --- ## Summary diff --git a/src/main/java/Maps/HashMap/HashMapProblems.java b/src/main/java/Maps/HashMap/HashMapProblems.java index 04b5567..b05a515 100644 --- a/src/main/java/Maps/HashMap/HashMapProblems.java +++ b/src/main/java/Maps/HashMap/HashMapProblems.java @@ -35,7 +35,7 @@ public static void main(String[] args) { public static void addItem(Map map, String item, int quantity) { // TODO: Implement this method - + map.put(item, quantity); } /* @@ -50,7 +50,8 @@ public static int getQuantity(Map map, String item) { // TODO: Implement this method - return 0; + // Return 0 if the item is not in the map + return map.getOrDefault(item, 0); } /* @@ -64,6 +65,7 @@ public static int getQuantity(Map map, String item) { public static void updateQuantity(Map map, String item, int newQuantity) { // TODO: Implement this method + map.put(item, newQuantity); } @@ -78,6 +80,7 @@ public static void updateQuantity(Map map, String item, int new public static void removeItem(Map map, String item) { // TODO: Implement this method + map.remove(item); } @@ -92,7 +95,12 @@ public static void removeItem(Map map, String item) { public static Map countFrequency(List numbers) { // TODO: Implement this method + Map freqMap = new HashMap<>(); + + for (int num : numbers) { + // If number exists, increment count; else start with 1 + freqMap.put(num, freqMap.getOrDefault(num, 0) + 1); + } - return null; + return freqMap; } -} diff --git a/src/main/java/Maps/HashMap/README.md b/src/main/java/Maps/HashMap/README.md index 321d09b..5d0addd 100644 --- a/src/main/java/Maps/HashMap/README.md +++ b/src/main/java/Maps/HashMap/README.md @@ -184,10 +184,61 @@ Output: ## Practice Ideas * Count word frequencies in a sentence + +Map wordCount = new HashMap<>(); +String sentence = "hello world hello java"; + +for (String word : sentence.split("\\s+")) { +wordCount.put(word, wordCount.getOrDefault(word, 0) + 1); +} + +System.out.println(wordCount); // {hello=2, world=1, java=1} + * Implement a phone directory + +Map phoneDirectory = new HashMap<>(); + +// Add contact +phoneDirectory.put("Alice", "123-456"); + +// Update +phoneDirectory.put("Alice", "987-654"); + +// Retrieve +System.out.println(phoneDirectory.get("Alice")); // 987-654 + +// Remove +phoneDirectory.remove("Alice"); + * Find the first non-repeating character + +String str = "swiss"; +Map freq = new LinkedHashMap<>(); + +for (char c : str.toCharArray()) { +freq.put(c, freq.getOrDefault(c, 0) + 1); +} + +for (Map.Entry entry : freq.entrySet()) { +if (entry.getValue() == 1) { +System.out.println(entry.getKey()); // 'w' +break; +} +} + * Solve the Two-Sum problem +int[] nums = {2, 7, 11, 15}; +int target = 9; +Map map = new HashMap<>(); + +for (int i = 0; i < nums.length; i++) { +int complement = target - nums[i]; +if (map.containsKey(complement)) { +System.out.println("Indices: " + map.get(complement) + ", " + i); +} +map.put(nums[i], i); +} --- ## Summary diff --git a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java index e8bbdc2..9155c2a 100644 --- a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java +++ b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java @@ -33,7 +33,14 @@ public static void main(String[] args) { public static void addStudent(Map map, String name, int grade) { // TODO: Implement this method + map.put(name, grade); + } + Map students = new LinkedHashMap<>(); + + addStudent(students, "Jordan", 90); + addStudent(students, "Alex", 85); + System.out.println(students); } /* @@ -47,9 +54,19 @@ public static void addStudent(Map map, String name, int grade) public static void updateGrade(Map map, String name, int newGrade) { // TODO: Implement this method + // Update only if the student exists + if (map.containsKey(name)) { + map.put(name, newGrade); + } - } + Map students = new LinkedHashMap<>(); + students.put("Taylor", 85); + + updateGrade(students, "Taylor", 92); + + System.out.println(students); + } /* Problem 3 Remove a student from the LinkedHashMap. @@ -61,9 +78,15 @@ public static void updateGrade(Map map, String name, int newGra public static void removeStudent(Map map, String name) { // TODO: Implement this method - + map.remove(name); } + Map students = new LinkedHashMap<>(); +students.put("Morgan", 88); +students.put("Jordan", 90); + + removeStudent(students, "Morgan"); +System.out.println(students); /* Problem 4 Return the first student inserted into the LinkedHashMap. @@ -72,13 +95,33 @@ public static void removeStudent(Map map, String name) { Input: {"Jordan"=90, "Taylor"=85} Output: "Jordan" */ - public static String getFirstInserted(Map map) { - // TODO: Implement this method +import java.util.Map; +import java.util.LinkedHashMap; - return null; - } + public class Main { + public static String getFirstInserted(Map map) { + // LinkedHashMap preserves insertion order + if (map == null || map.isEmpty()) { + return null; // handle empty map + } + + // Iterate over keys and return the first one + for (String key : map.keySet()) { + return key; + } + + return null; // fallback, though it should never reach here + } + public static void main(String[] args) { + Map students = new LinkedHashMap<>(); + students.put("Jordan", 90); + students.put("Taylor", 85); + + System.out.println(getFirstInserted(students)); // Output: Jordan + } + } /* Problem 5 Given a list of words, return a LinkedHashMap that counts @@ -88,10 +131,26 @@ public static String getFirstInserted(Map map) { Input: ["apple","banana","apple","orange"] Output: {apple=2, banana=1, orange=1} */ - public static Map wordFrequency(List words) { + import java.util.*; - // TODO: Implement this method + public class Main { - return null; - } -} + public static Map wordFrequency(List words) { + Map frequencyMap = new LinkedHashMap<>(); + + if (words == null) return frequencyMap; // handle null input + + for (String word : words) { + // If the word is already in the map, increment count; otherwise, set to 1 + frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1); + } + + return frequencyMap; + } + + public static void main(String[] args) { + List words = Arrays.asList("apple","banana","apple","orange"); + Map result = wordFrequency(words); + System.out.println(result); // Output: {apple=2, banana=1, orange=1} + } + } \ No newline at end of file diff --git a/src/main/java/Maps/LinkedHashMap/README.md b/src/main/java/Maps/LinkedHashMap/README.md index 82818a8..bd0bd7f 100644 --- a/src/main/java/Maps/LinkedHashMap/README.md +++ b/src/main/java/Maps/LinkedHashMap/README.md @@ -183,10 +183,83 @@ Output: ## 🧪 Practice Ideas * Count word frequency while preserving order + +import java.util.*; + +public class Practice1 { +public static void main(String[] args) { +List words = Arrays.asList("apple","banana","apple","orange"); +LinkedHashMap freqMap = new LinkedHashMap<>(); + + for (String word : words) { + freqMap.put(word, freqMap.getOrDefault(word, 0) + 1); + } + + System.out.println(freqMap); // Output: {apple=2, banana=1, orange=1} + } +} + * Build a simple cache + +import java.util.*; + +public class Practice2 { +public static void main(String[] args) { +LinkedHashMap cache = new LinkedHashMap(3, 0.75f, false) { +protected boolean removeEldestEntry(Map.Entry eldest) { +return size() > 3; // remove oldest entry when size > 3 +} +}; + + cache.put(1, "A"); + cache.put(2, "B"); + cache.put(3, "C"); + cache.put(4, "D"); // 1 will be removed + + System.out.println(cache); // Output: {2=B, 3=C, 4=D} + } +} + * Remove duplicates from a list while preserving order + +import java.util.*; + +public class Practice3 { +public static void main(String[] args) { +List list = Arrays.asList(1,2,3,2,1,4); +LinkedHashMap uniqueMap = new LinkedHashMap<>(); + + for (Integer num : list) { + uniqueMap.put(num, true); // only keeps first occurrence + } + + List result = new ArrayList<>(uniqueMap.keySet()); + System.out.println(result); // Output: [1, 2, 3, 4] + } +} + * Track user activity history +import java.util.*; + +public class Practice4 { +public static void main(String[] args) { +LinkedHashMap userActivity = new LinkedHashMap<>(); + + userActivity.put("user1", "Login"); + userActivity.put("user2", "View Page"); + userActivity.put("user1", "Upload File"); // updates value but preserves insertion order + userActivity.put("user3", "Logout"); + + for (Map.Entry entry : userActivity.entrySet()) { + System.out.println(entry.getKey() + " -> " + entry.getValue()); + } + // Output: + // user1 -> Upload File + // user2 -> View Page + // user3 -> Logout + } +} --- ## 🏁 Summary diff --git a/src/main/java/Maps/MapBasics/README.md b/src/main/java/Maps/MapBasics/README.md index e3b3241..814b96a 100644 --- a/src/main/java/Maps/MapBasics/README.md +++ b/src/main/java/Maps/MapBasics/README.md @@ -174,10 +174,66 @@ Actual performance depends on the implementation (`HashMap`, `TreeMap`, etc.). ## Practice Ideas * Count word frequencies in a sentence + +import java.util.*; + +public class WordFrequencyDemo { +public static void main(String[] args) { +String sentence = "apple banana apple orange banana apple"; +String[] words = sentence.split(" "); + + Map freq = new HashMap<>(); + for (String word : words) { + freq.put(word, freq.getOrDefault(word, 0) + 1); + }//Use getOrDefault(key, defaultValue) to simplify counting + + System.out.println(freq); + // Output: {orange=1, banana=2, apple=3} + } +} * Store student names and grades + +Map studentGrades = new HashMap<>(); +studentGrades.put("Alice", 90); +studentGrades.put("Bob", 85); +studentGrades.put("Charlie", 95); + +System.out.println(studentGrades); +// Output: {Alice=90, Bob=85, Charlie=95} +💡// Use LinkedHashMap to preserve insertion order. + + * Build a phone directory + +Map phoneDirectory = new HashMap<>(); +phoneDirectory.put("Alice", "123-456-7890"); +phoneDirectory.put("Bob", "987-654-3210"); + +System.out.println(phoneDirectory); +// Output: {Alice=123-456-7890, Bob=987-654-3210} +//Use Map> if a person has multiple numbers. + * Find the most frequent number in a list +//Use a Map to count occurrences and then find the max. + +List numbers = Arrays.asList(1,3,2,3,4,3); + +Map freq = new HashMap<>(); +for (Integer num : numbers) { +freq.put(num, freq.getOrDefault(num, 0) + 1); +} + +int mostFrequent = numbers.get(0); +int maxCount = 0; + +for (Map.Entry entry : freq.entrySet()) { +if (entry.getValue() > maxCount) { +maxCount = entry.getValue(); +mostFrequent = entry.getKey(); +} +} +System.out.println("Most frequent: " + mostFrequent); // Output: 3 --- ## Summary diff --git a/src/main/java/Maps/README.md b/src/main/java/Maps/README.md index d8e7adb..ab0f723 100644 --- a/src/main/java/Maps/README.md +++ b/src/main/java/Maps/README.md @@ -216,10 +216,60 @@ Keys are automatically sorted. ## Practice Ideas * Store numbers and return them in sorted order + +//use a TreeSet to automatically store unique numbers in sorted order. +import java.util.*; + +TreeSet numbers = new TreeSet<>(); +numbers.add(50); +numbers.add(20); +numbers.add(40); +numbers.add(20); // duplicate, ignored + +System.out.println(numbers); // Output: [20, 40, 50] + * Build a leaderboard sorted by score + +//Use a TreeMap where key = score (sorted automatically), value = player name. +TreeMap leaderboard = new TreeMap<>(); +leaderboard.put(90, "Alice"); +leaderboard.put(95, "Bob"); +leaderboard.put(85, "Charlie"); + +System.out.println(leaderboard); +// Output: {85=Charlie, 90=Alice, 95=Bob} +//Use descendingMap() if we want highest score first: +System.out.println(leaderboard.descendingMap()); +// Output: {95=Bob, 90=Alice, 85=Charlie} + * Find the closest value to a target number + +TreeSet numbers = new TreeSet<>(Arrays.asList(10, 20, 30, 40)); +int target = 25; + +Integer ceil = numbers.ceiling(target); // smallest >= target → 30 +Integer floor = numbers.floor(target); // largest <= target → 20 + +// Find closest +int closest = (ceil != null && floor != null) +? (Math.abs(ceil - target) < Math.abs(floor - target) ? ceil : floor) +: (ceil != null ? ceil : floor); + +System.out.println("Closest to " + target + " is " + closest); // Output: 20 or 30 + * Return elements in a range using `subMap()` +TreeMap players = new TreeMap<>(); +players.put(1, "A"); +players.put(2, "B"); +players.put(3, "C"); +players.put(4, "D"); + +Map sub = players.subMap(2, 4); // keys 2 and 3 +System.out.println(sub); // Output: {2=B, 3=C} + +// subMap(fromKey, toKey) is inclusive-exclusive by default. +//Use subMap(fromKey, boolean fromInclusive, toKey, boolean toInclusive) to customize inclusivity. --- ## Summary diff --git a/src/main/java/Maps/TreeMap/TreeMapProblems.java b/src/main/java/Maps/TreeMap/TreeMapProblems.java index b101d2e..74d0ebe 100644 --- a/src/main/java/Maps/TreeMap/TreeMapProblems.java +++ b/src/main/java/Maps/TreeMap/TreeMapProblems.java @@ -28,11 +28,18 @@ public static void main(String[] args) { Input: (1, "Jordan") Output: {1="Jordan"} */ - public static void addPlayer(TreeMap map, int rank, String name) { + // TODO: Implement this method + // TreeMap, adding a key-value pair is just like a regular map using put(). + // Since TreeMap automatically sorts keys, the map will stay sorted by rank. + +import java.util.TreeMap; + + public static void addPlayer(TreeMap map, int rank, String name) { + map.put(rank, name); + } - } /* Problem 2 @@ -42,13 +49,19 @@ Return the player with the highest ranking (smallest key). Input: {1="Jordan", 2="Taylor"} Output: "Jordan" */ - public static String getTopPlayer(TreeMap map) { + // TODO: Implement this method + // TreeMap, the smallest key can be retrieved with firstKey(), and then you can get the corresponding value. - return null; - } +import java.util.TreeMap; + public static String getTopPlayer(TreeMap map) { + if (map.isEmpty()) { + return null; // or throw exception if you prefer + } + return map.get(map.firstKey()); + } /* Problem 3 Return the player with the lowest ranking (largest key). @@ -57,12 +70,18 @@ Return the player with the lowest ranking (largest key). Input: {1="Jordan", 2="Taylor"} Output: "Taylor" */ - public static String getLowestPlayer(TreeMap map) { - // TODO: Implement this method - return null; - } + // TreeMap, the largest key can be retrieved with lastKey(), and then you get the corresponding value. + +import java.util.TreeMap; + + public static String getLowestPlayer(TreeMap map) { + if (map.isEmpty()) { + return null; // or throw exception if you prefer + } + return map.get(map.lastKey()); + } /* Problem 4 @@ -72,11 +91,21 @@ public static String getLowestPlayer(TreeMap map) { Input: remove rank 2 Output: player removed */ - public static void removePlayer(TreeMap map, int rank) { + // TODO: Implement this method + // TreeMap, you can remove a key-value pair using the remove() method with the key (rank). - } +import java.util.TreeMap; + + public static void removePlayer(TreeMap map, int rank) { + if (map.containsKey(rank)) { + map.remove(rank); + System.out.println("Player with rank " + rank + " removed."); + } else { + System.out.println("No player found with rank " + rank + "."); + } + } /* Problem 5 @@ -86,10 +115,18 @@ public static void removePlayer(TreeMap map, int rank) { Input: rank=2, map={1="A",2="B",3="C"} Output: 3 */ - public static Integer getNextRank(TreeMap map, int rank) { // TODO: Implement this method - return null; - } -} + // In a TreeMap, we can use higherKey(key) to get the smallest key strictly greater than the given key. That’s exactly what we need for the next higher rank. + +import java.util.TreeMap; + + public static Integer getNextRank(TreeMap map, int rank) { + return map.higherKey(rank); // returns null if no higher key exists + } + + //higherKey(key) → next higher key +//lowerKey(key) → next lower key +//ceilingKey(key) → smallest key ≥ given key +//floorKey(key) → largest key ≤ given key \ No newline at end of file diff --git a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java index dac03cf..1dc03b6 100644 --- a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java +++ b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java @@ -31,7 +31,7 @@ public static void main(String[] args) { public static void addToFront(ArrayDeque deque, int value) { // TODO: Implement this method - + deque.addFirst(value); } /* @@ -45,6 +45,7 @@ public static void addToFront(ArrayDeque deque, int value) { public static void addToBack(ArrayDeque deque, int value) { // TODO: Implement this method + deque.addLast(value); } @@ -58,10 +59,11 @@ public static void addToBack(ArrayDeque deque, int value) { */ public static void removeFront(ArrayDeque deque) { - // TODO: Implement this method + if (!deque.isEmpty()) { + deque.removeFirst(); + } } - /* Problem 4 Remove the element at the BACK of the deque. @@ -73,9 +75,13 @@ public static void removeFront(ArrayDeque deque) { public static void removeBack(ArrayDeque deque) { // TODO: Implement this method + if (!deque.isEmpty()) { + deque.removeLast(); + } } + /* Problem 5 Return the FIRST element in the deque without removing it. @@ -88,7 +94,8 @@ public static Integer peekFront(ArrayDeque deque) { // TODO: Implement this method - return null; + return deque.peekFirst(); + } /* @@ -103,6 +110,7 @@ public static Integer peekBack(ArrayDeque deque) { // TODO: Implement this method - return null; + return deque.peekLast(); + } -} + diff --git a/src/main/java/Queues/ArrayDeque/README.md b/src/main/java/Queues/ArrayDeque/README.md index cb5878c..84522a6 100644 --- a/src/main/java/Queues/ArrayDeque/README.md +++ b/src/main/java/Queues/ArrayDeque/README.md @@ -189,10 +189,74 @@ Task1 ## Practice Ideas * Implement a stack using ArrayDeque + +import java.util.ArrayDeque; + +ArrayDeque stack = new ArrayDeque<>(); + +// Push elements +stack.push(10); +stack.push(20); +stack.push(30); + +// Pop elements +System.out.println(stack.pop()); // 30 +System.out.println(stack.pop()); // 20 +System.out.println(stack); // [10] +//push() → add to top, pop() → remove from top, peek() → view top element. + * Reverse a string using a stack + +String str = "hello"; +ArrayDeque stack = new ArrayDeque<>(); + +for (char c : str.toCharArray()) { +stack.push(c); +} + +StringBuilder reversed = new StringBuilder(); +while (!stack.isEmpty()) { +reversed.append(stack.pop()); +} + +System.out.println(reversed); // Output: "olleh" + * Simulate a queue of tasks + +//ArrayDeque also works as a FIFO queue: +//offer() → add to end, poll() → remove from front, peek() → view front + +ArrayDeque queue = new ArrayDeque<>(); + +// Enqueue tasks +queue.offer("Task1"); +queue.offer("Task2"); +queue.offer("Task3"); + +// Dequeue tasks +System.out.println(queue.poll()); // Task1 +System.out.println(queue.poll()); // Task2 +System.out.println(queue); // [Task3] + * Check balanced parentheses + public static boolean isBalanced(String expr) { + ArrayDeque stack = new ArrayDeque<>(); + + for (char c : expr.toCharArray()) { + if (c == '(') { + stack.push(c); + } else if (c == ')') { + if (stack.isEmpty()) return false; + stack.pop(); + } + } + return stack.isEmpty(); + } + +// Example +System.out.println(isBalanced("(())")); // true +System.out.println(isBalanced("(()")); // false --- ## Summary diff --git a/src/main/java/Queues/Deque/DequeProblems.java b/src/main/java/Queues/Deque/DequeProblems.java index 7ef0c06..2ff66ab 100644 --- a/src/main/java/Queues/Deque/DequeProblems.java +++ b/src/main/java/Queues/Deque/DequeProblems.java @@ -17,12 +17,16 @@ public static void main(String[] args) { Input: value = 5 Output: [5] */ + //addFirst() throws an exception if the deque is full (rare, usually unbounded). + //offerFirst() returns false instead of throwing an exception if it cannot add. public static void addFront(Deque deque, int value) { // TODO: Implement this method - + deque.addFirst(value); // adds value to the front + // alternatively: deque.offerFirst(value); } + /* Problem 2 Add a value to the BACK of the deque. @@ -31,10 +35,20 @@ public static void addFront(Deque deque, int value) { Input: value = 10 Output: [5,10] */ - public static void addBack(Deque deque, int value) { + // TODO: Implement this method + //addLast() → adds to the end (back) of the deque. + //offerLast() → safer version, returns false if it cannot add. + //Using both addFront() and addBack() tp simulate double-ended queues easily. + +import java.util.Deque; + + public static void addBack(Deque deque, int value) { + deque.addLast(value); // adds value to the back + // alternatively: deque.offerLast(value); + } } /* @@ -45,12 +59,18 @@ public static void addBack(Deque deque, int value) { Input: [5,10,15] Output: 5 */ + //In a Deque, we can remove and return the front element using removeFirst() or pollFirst(). + // removeFirst() throws an exception if the deque is empty. + // pollFirst() returns null if the deque is empty. public static Integer removeFront(Deque deque) { // TODO: Implement this method - return null; + return deque.pollFirst(); // removes and returns the front element, or null if empty } +//pollFirst() is preferred when you want null instead of an exception for empty deques. +//removeFirst() can be used if you want to enforce that the deque must have elements + /* Problem 4 @@ -60,27 +80,38 @@ public static Integer removeFront(Deque deque) { Input: [5,10,15] Output: 15 */ - public static Integer removeBack(Deque deque) { + // TODO: Implement this method - return null; - } +//In a Deque, you can remove and return the back element using removeLast() or pollLast(). +//removeLast() throws an exception if the deque is empty. +//pollLast() returns null if the deque is empty (safer). - /* - Problem 5 + import java.util.Deque; + +public static Integer removeBack(Deque deque) { + return deque.pollLast(); // removes and returns the back element, or null if empty +} + + /* Problem 5 Return the FRONT element without removing it. Example Input: [5,10,15] Output: 5 */ - public static Integer peekFront(Deque deque) { // TODO: Implement this method - return null; - } + // In a Deque, you can return the front element without removing it using peekFirst() or getFirst(). + // peekFirst() returns null if the deque is empty. + +import java.util.Deque; + + public static Integer peekFront(Deque deque) { + return deque.peekFirst(); // returns the front element without removing it, or null if empty + } /* Problem 6 @@ -90,11 +121,17 @@ public static Integer peekFront(Deque deque) { Input: [5,10,15] Output: 15 */ - public static Integer peekBack(Deque deque) { + // TODO: Implement this method - return null; - } + // In a Deque, you can return the back element without removing it using peekLast() or getLast(). + // peekLast() returns null if the deque is empty (safe). + // getLast() throws NoSuchElementException if the deque is empty. -} + +import java.util.Deque; + + public static Integer peekBack(Deque deque) { + return deque.peekLast(); // returns the back element without removing it, or null if empty + } \ No newline at end of file diff --git a/src/main/java/Queues/Deque/README.md b/src/main/java/Queues/Deque/README.md index da17b50..7d0546b 100644 --- a/src/main/java/Queues/Deque/README.md +++ b/src/main/java/Queues/Deque/README.md @@ -198,10 +198,75 @@ Task1 ## Practice Ideas * Implement a stack using Deque + +import java.util.ArrayDeque; +import java.util.Deque; + +Deque stack = new ArrayDeque<>(); + +// Push elements +stack.push(10); +stack.push(20); +stack.push(30); + +// Peek top +System.out.println(stack.peek()); // 30 + +// Pop elements +System.out.println(stack.pop()); // 30 +System.out.println(stack); // [20, 10] +// Deque is preferred over Stack because it’s faster and modern. + * Implement a queue using Deque + Deque queue = new ArrayDeque<>(); + +// Enqueue tasks +queue.offer("Task1"); +queue.offer("Task2"); +queue.offer("Task3"); + +// Peek front +System.out.println(queue.peek()); // Task1 + +// Dequeue tasks +System.out.println(queue.poll()); // Task1 +System.out.println(queue); // [Task2, Task3] +// offer() adds to the back, poll() removes from the front + * Reverse elements using Deque -* Build a browser history system +//reverse elements using stack behavior (push/pop) or addFirst/addLast: +Deque deque = new ArrayDeque<>(); +deque.add(1); +deque.add(2); +deque.add(3); + +// Reverse using stack operations +Deque reversed = new ArrayDeque<>(); +while (!deque.isEmpty()) { +reversed.push(deque.poll()); +} + +System.out.println(reversed); // Output: [3, 2, 1] + +* Build a browser history system + //Use a stack for back/forward history: + Deque backStack = new ArrayDeque<>(); + Deque forwardStack = new ArrayDeque<>(); + +// User visits pages +backStack.push("google.com"); +backStack.push("openai.com"); +backStack.push("stackoverflow.com"); + +// Go back +forwardStack.push(backStack.pop()); // visit previous page +System.out.println("Current page: " + backStack.peek()); // openai.com + +// Go forward +backStack.push(forwardStack.pop()); +System.out.println("Current page: " + backStack.peek()); // stackoverflow.com +// This simulates back/forward navigation in browsers. --- ## Summary diff --git a/src/main/java/Queues/PriorityQueue/README.md b/src/main/java/Queues/PriorityQueue/README.md index 685cb11..56a5d39 100644 --- a/src/main/java/Queues/PriorityQueue/README.md +++ b/src/main/java/Queues/PriorityQueue/README.md @@ -187,10 +187,93 @@ Use it when tasks must be processed by priority, such as: ## Practice Ideas * Find the K smallest numbers + +//Use a min-heap (PriorityQueue) to efficiently get smallest numbers: +import java.util.*; + +List numbers = Arrays.asList(7, 2, 5, 3, 9); +int k = 3; + +PriorityQueue minHeap = new PriorityQueue<>(numbers); +List kSmallest = new ArrayList<>(); + +for (int i = 0; i < k && !minHeap.isEmpty(); i++) { +kSmallest.add(minHeap.poll()); +} + +System.out.println(kSmallest); // Output: [2, 3, 5] +// PriorityQueue automatically keeps elements sorted in natural order (min at top). + * Implement a task scheduler + +//Use a priority queue where tasks have priority (smaller number = higher priority): + class Task implements Comparable { + String name; + int priority; + + Task(String name, int priority) { + this.name = name; + this.priority = priority; + } + + @Override + public int compareTo(Task other) { + return Integer.compare(this.priority, other.priority); + } + } + +PriorityQueue tasks = new PriorityQueue<>(); +tasks.offer(new Task("Write report", 2)); +tasks.offer(new Task("Email client", 1)); +tasks.offer(new Task("Update code", 3)); + +while (!tasks.isEmpty()) { +Task t = tasks.poll(); +System.out.println("Processing: " + t.name + " (priority " + t.priority + ")"); +} +// Output processes tasks in priority order: Email client, Write report, Update code + * Build a leaderboard system + +//Use a max-heap (PriorityQueue with comparator) to get top scores: +PriorityQueue leaderboard = new PriorityQueue<>(Collections.reverseOrder()); +leaderboard.add(90); +leaderboard.add(75); +leaderboard.add(95); + +System.out.println(leaderboard.poll()); // 95 +System.out.println(leaderboard.poll()); // 90 +// Collections.reverseOrder() makes it a max-heap instead of min-heap. + * Merge multiple sorted lists +//Use a priority queue to efficiently merge k sorted lists: +List> lists = List.of( +List.of(1, 4, 7), +List.of(2, 5, 8), +List.of(3, 6, 9) +); + +PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0])); +// Store {value, listIndex, elementIndex} in heap +for (int i = 0; i < lists.size(); i++) { +if (!lists.get(i).isEmpty()) { +pq.offer(new int[]{lists.get(i).get(0), i, 0}); +} +} + +List merged = new ArrayList<>(); +while (!pq.isEmpty()) { +int[] top = pq.poll(); +merged.add(top[0]); +int listIndex = top[1], elemIndex = top[2]; +if (elemIndex + 1 < lists.get(listIndex).size()) { +pq.offer(new int[]{lists.get(listIndex).get(elemIndex + 1), listIndex, elemIndex + 1}); +} +} + +System.out.println(merged); // Output: [1,2,3,4,5,6,7,8,9] +//This is the classic k-way merge using a heap. --- ## Summary diff --git a/src/main/java/Queues/Queue/README.md b/src/main/java/Queues/Queue/README.md index f9e463a..caa6ce6 100644 --- a/src/main/java/Queues/Queue/README.md +++ b/src/main/java/Queues/Queue/README.md @@ -173,10 +173,114 @@ The first element added is the first removed. ## Practice Ideas * Simulate a printer queue + +LinkedHashMap printerQueue = new LinkedHashMap<>(); +printerQueue.put(101, "Document1.pdf"); +printerQueue.put(102, "Report.docx"); + +// Process first job +Integer firstJobId = printerQueue.keySet().iterator().next(); +String firstJob = printerQueue.remove(firstJobId); +System.out.println("Printing: " + firstJob); + * Process customer service requests + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Scanner; + +public class CustomerServiceQueue { + + public static void main(String[] args) { + LinkedHashMap requests = new LinkedHashMap<>(); + Scanner scanner = new Scanner(System.in); + int nextRequestId = 1; + + while (true) { + System.out.println("\n1. Add Request"); + System.out.println("2. Update Request"); + System.out.println("3. Process Next Request"); + System.out.println("4. Show All Requests"); + System.out.println("5. Exit"); + System.out.print("Choose option: "); + int option = scanner.nextInt(); + scanner.nextLine(); // consume newline + + switch (option) { + case 1: + System.out.print("Enter customer info / request description: "); + String info = scanner.nextLine(); + requests.put(nextRequestId, info); + System.out.println("Request added with ID: " + nextRequestId); + nextRequestId++; + break; + + case 2: + System.out.print("Enter request ID to update: "); + int updateId = scanner.nextInt(); + scanner.nextLine(); // consume newline + if (requests.containsKey(updateId)) { + System.out.print("Enter new details: "); + String newInfo = scanner.nextLine(); + requests.put(updateId, newInfo); // updates value + System.out.println("Request " + updateId + " updated."); + } else { + System.out.println("Request ID not found."); + } + break; + + case 3: + if (!requests.isEmpty()) { + int firstId = requests.keySet().iterator().next(); + String firstRequest = requests.remove(firstId); + System.out.println("Processing request ID " + firstId + ": " + firstRequest); + } else { + System.out.println("No requests to process."); + } + break; + + case 4: + System.out.println("All pending requests:"); + for (Map.Entry entry : requests.entrySet()) { + System.out.println("ID " + entry.getKey() + " -> " + entry.getValue()); + } + break; + + case 5: + System.out.println("Exiting..."); + scanner.close(); + return; + + default: + System.out.println("Invalid option. Try again."); + } + } + } +} + * Implement a ticketing system + +LinkedHashMap tickets = new LinkedHashMap<>(); +tickets.put(1, "UserA - Issue1"); +tickets.put(2, "UserB - Issue2"); + +// Resolve ticket 1 +tickets.remove(1); +System.out.println(tickets); // Output: {2=UserB - Issue2} + * Perform breadth-first search on a graph +LinkedHashMap visited = new LinkedHashMap<>(); +Queue queue = new LinkedList<>(); + +visited.put("A", true); +queue.add("A"); + +while(!queue.isEmpty()) { +String node = queue.poll(); +System.out.println("Visiting: " + node); +// Add neighbors if not visited +} --- ## Summary diff --git a/src/main/java/Sets/HashSet/HashSetProblems.java b/src/main/java/Sets/HashSet/HashSetProblems.java index a36c570..11dd400 100644 --- a/src/main/java/Sets/HashSet/HashSetProblems.java +++ b/src/main/java/Sets/HashSet/HashSetProblems.java @@ -21,7 +21,7 @@ public static void main(String[] args) { public static void addElement(Set set, String value) { // TODO: Implement this method - + set.add(value); } /* @@ -35,8 +35,8 @@ public static void addElement(Set set, String value) { public static boolean containsValue(Set set, String value) { // TODO: Implement this method + return set.contains(value); - return false; } /* @@ -50,7 +50,7 @@ public static boolean containsValue(Set set, String value) { public static void removeValue(Set set, String value) { // TODO: Implement this method - + set.remove(value); } /* @@ -65,7 +65,7 @@ public static int getUniqueCount(Set set) { // TODO: Implement this method - return 0; + return set.size(); } /* @@ -80,6 +80,7 @@ public static Set getUniqueValues(List numbers) { // TODO: Implement this method - return null; + return new HashSet<>(numbers); + } } diff --git a/src/main/java/Sets/HashSet/README.md b/src/main/java/Sets/HashSet/README.md index e2e1df7..22ec63a 100644 --- a/src/main/java/Sets/HashSet/README.md +++ b/src/main/java/Sets/HashSet/README.md @@ -157,13 +157,68 @@ The duplicate `"Apple"` is not stored. ## Practice Ideas * Remove duplicates from a list + +//Use a HashSet to remove duplicates (order not preserved) or a LinkedHashSet (order preserved): +import java.util.*; + +List numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5); +Set uniqueNumbers = new LinkedHashSet<>(numbers); // preserves order + +System.out.println(uniqueNumbers); // Output: [1, 2, 3, 4, 5] + * Count unique numbers in an array + +//Just add all elements to a Set and check the size: +int[] arr = {1, 2, 2, 3, 4, 4, 5}; +Set unique = new HashSet<>(); +for (int num : arr) { +unique.add(num); +} + +System.out.println("Unique count: " + unique.size()); // Output: 5 + * Track visited nodes in graph traversal -* Compare HashSet with TreeSet ordering +import java.util.*; + +Map> graph = Map.of( +1, Arrays.asList(2, 3), +2, Arrays.asList(4), +3, Arrays.asList(4), +4, Arrays.asList() +); + +Set visited = new HashSet<>(); +Stack stack = new Stack<>(); +stack.push(1); + +while (!stack.isEmpty()) { +int node = stack.pop(); +if (!visited.contains(node)) { +visited.add(node); +for (int neighbor : graph.get(node)) { +stack.push(neighbor); +} +} +} + +System.out.println("Visited nodes: " + visited); // Output: [1,2,3,4] + +* Compare HashSet with TreeSet ordering + //HashSet → unordered, fast O(1) lookup. + //TreeSet → sorted, O(log n) lookup. +* + Set hashSet = new HashSet<>(Arrays.asList(5, 1, 3, 2)); + Set treeSet = new TreeSet<>(Arrays.asList(5, 1, 3, 2)); + +System.out.println("HashSet: " + hashSet); // Output order may vary: [1, 2, 3, 5] or different +System.out.println("TreeSet: " + treeSet); // Output sorted: [1, 2, 3, 5] --- ## Summary +Use HashSet for fast lookup & uniqueness. +Use LinkedHashSet if you want insertion order preserved. +Use TreeSet if you want sorted order automatically. HashSet is a **fast implementation of the Set interface that stores unique elements using hashing**. diff --git a/src/main/java/Sets/LinkedHashSet/README.md b/src/main/java/Sets/LinkedHashSet/README.md index 003f3b9..07d40be 100644 --- a/src/main/java/Sets/LinkedHashSet/README.md +++ b/src/main/java/Sets/LinkedHashSet/README.md @@ -153,9 +153,61 @@ The duplicate `"Apple"` is ignored, and the insertion order is preserved. ## Practice Ideas * Remove duplicates from a list while preserving order + +import java.util.*; + +public class RemoveDuplicatesExample { +public static void main(String[] args) { +List items = Arrays.asList("apple", "banana", "apple", "orange", "banana"); + + // Use LinkedHashSet to remove duplicates while preserving order + LinkedHashSet uniqueItems = new LinkedHashSet<>(items); + + // Convert back to list if needed + List result = new ArrayList<>(uniqueItems); + + System.out.println(result); // Output: [apple, banana, orange] + } +} * Store unique usernames in insertion order + +import java.util.*; + +public class UniqueUsernames { +public static void main(String[] args) { +LinkedHashSet usernames = new LinkedHashSet<>(); + + usernames.add("alice"); + usernames.add("bob"); + usernames.add("charlie"); + usernames.add("alice"); // duplicate, ignored + + System.out.println(usernames); // Output: [alice, bob, charlie] + } +} * Track unique visited pages +import java.util.*; + +public class VisitedPages { +public static void main(String[] args) { +LinkedHashSet visitedPages = new LinkedHashSet<>(); + + visitedPages.add("home.html"); + visitedPages.add("about.html"); + visitedPages.add("contact.html"); + visitedPages.add("home.html"); // duplicate, ignored + + System.out.println("Visited pages in order:"); + for (String page : visitedPages) { + System.out.println(page); + } + // Output: + // home.html + // about.html + // contact.html + } +} --- ## Summary diff --git a/src/main/java/Sets/TreeSet/README.md b/src/main/java/Sets/TreeSet/README.md index c040dc9..090b6a0 100644 --- a/src/main/java/Sets/TreeSet/README.md +++ b/src/main/java/Sets/TreeSet/README.md @@ -198,10 +198,81 @@ The elements are stored in sorted order. ## Practice Ideas * Store numbers and automatically sort them + +import java.util.*; + +public class SortedNumbersExample { +public static void main(String[] args) { +TreeSet numbers = new TreeSet<>(); + + numbers.add(42); + numbers.add(7); + numbers.add(19); + numbers.add(7); // duplicate ignored + + System.out.println(numbers); // Output: [7, 19, 42] + } +} * Find the smallest and largest elements + +import java.util.*; + +public class MinMaxExample { +public static void main(String[] args) { +TreeSet numbers = new TreeSet<>(Arrays.asList(10, 5, 20, 15)); + + int smallest = numbers.first(); + int largest = numbers.last(); + + System.out.println("Smallest: " + smallest); // 5 + System.out.println("Largest: " + largest); // 20 + } +} * Retrieve values within a range + +import java.util.*; + +public class RangeExample { +public static void main(String[] args) { +TreeSet numbers = new TreeSet<>(Arrays.asList(10, 5, 20, 15, 25)); + + // Retrieve numbers between 10 (inclusive) and 20 (inclusive) + SortedSet range = numbers.subSet(10, true, 20, true); + + System.out.println(range); // Output: [10, 15, 20] + } +}import java.util.*; + +public class UniqueScores { +public static void main(String[] args) { +TreeSet scores = new TreeSet<>(); + + scores.add(85); + scores.add(92); + scores.add(76); + scores.add(85); // duplicate ignored + + System.out.println("Sorted unique scores: " + scores); + // Output: [76, 85, 92] + } +} * Track unique sorted scores +import java.util.*; + +public class UniqueScores { +public static void main(String[] args) { +TreeSet scores = new TreeSet<>(); + + scores.add(85); + scores.add(92); + scores.add(76); + scores.add(85); // duplicate ignored + + System.out.println("Sorted unique scores: " + scores); + // Output: [76, 85, 92] + } +} --- ## Summary @@ -211,6 +282,8 @@ TreeSet is a **sorted Set implementation backed by a balanced tree**. Key characteristics: * Unique elements only + + * Automatically sorted * O(log n) operations * Supports range and navigation operations diff --git a/src/main/java/Stack.java b/src/main/java/Stack.java index 88afd00..4b51926 100644 --- a/src/main/java/Stack.java +++ b/src/main/java/Stack.java @@ -1,2 +1,65 @@ -public class Stack { -} +import java.util.ArrayDeque; +import java.util.Deque; + + +//push() → add to top +//pop() → remove from top +//peek() → view top +//isEmpty() → check if stack is empty +//size() → current stack size +//Generic () to allow any type +//implement a stack using an ArrayDeque +// internally (preferred over Stack) or an array/list. +// Here’s a simple example using ArrayDeque: + +public class Stack { + private Deque stack; + + public Stack() { + stack = new ArrayDeque<>(); + } + + // Push an element onto the stack + public void push(T value) { + stack.push(value); + } + + // Pop an element from the stack + public T pop() { + return stack.pollFirst(); // returns null if empty + } + + // Peek at the top element without removing it + public T peek() { + return stack.peekFirst(); // returns null if empty + } + + // Check if the stack is empty + public boolean isEmpty() { + return stack.isEmpty(); + } + + // Get the size of the stack + public int size() { + return stack.size(); + } + + // For debugging: print stack elements + @Override + public String toString() { + return stack.toString(); + } + + // Demo + public static void main(String[] args) { + Stack s = new Stack<>(); + s.push(10); + s.push(20); + s.push(30); + + System.out.println("Stack: " + s); // [30, 20, 10] + System.out.println("Peek: " + s.peek()); // 30 + System.out.println("Pop: " + s.pop()); // 30 + System.out.println("Stack after pop: " + s); // [20, 10] + } +} \ No newline at end of file