Interpolation Search in Java: A Faster Alternative to Binary Search

DSA with Java.... Today I learnt about insertion sort algorithm. This algorithm starts at index 1, compares elements to the left and shifts elements to the right to insert a value. It has a complexity of 0(n^2) which is quite decent for small datasets but terrible for large datasets. It has less steps than bubble sort and it's best case scenario is 0(n) compared to selection sort, 0(n^2). I implemented insertion sort with Java to understand how the computer operates with such algorithm. Out of all these algorithms, which do you consider best to use in business applications? Cheers 🥂 #dsa #java #insertionsort #softwareengineering

Day 42 of #100DaysOfLeetCode 💻✅ Solved #704. Binary Search problem in Java. Approach: • Since the array is already sorted, applied the Binary Search algorithm • Initialized two pointers: left at the start and right at the end of the array • Calculated the middle index using (left + right) / 2 • If the middle element equals the target, returned the index • If the middle element is smaller than the target, moved the left pointer to mid + 1 • If the middle element is greater than the target, moved the right pointer to mid - 1 • Continued until the target was found or the search space became empty Performance: ✓ Runtime: 0 ms (Beats 100% submissions) 🚀 ✓ Memory: 48.32 MB (Beats 68.26% submissions) Key Learning: ✓ Practiced Binary Search with O(log n) time complexity ✓ Learned how pointer adjustments reduce the search space efficiently ✓ Strengthened understanding of searching algorithms in sorted arrays Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinarySearch #ProblemSolving #CodingJourney #100DaysOfCode

🔍 Linear Search in Java | DSA Practice Implemented Linear Search algorithm in Java as part of my DSA learning journey. 📌 What it does: Searches for a target element in an array by checking each element one by one. Returns the index if found, otherwise prints “Element not found”. 🧠 Concepts used: ∙ Array traversal using for loop ∙ Index tracking with a flag variable (index = -1) ∙ Early exit using break for efficiency #java #dsa #problem #solution #datastructure #algorithm #linearsearch

Day 32 of #100DaysOfLeetCode 💻✅ Solved #144. Binary Tree Preorder Traversal on LeetCode using Java. Approach: • Used recursion to perform preorder traversal • Followed Root → Left → Right order strictly • Added node value before traversing subtrees • Traversed left subtree first, then right subtree • Stored values in a list during traversal Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 42.83 MB (Beats 96.77% submissions) Key Learning: ✓ Strengthened understanding of preorder traversal pattern ✓ Clearly differentiated preorder from inorder traversal ✓ Improved recursive tree traversal implementation skills Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

Day 33 of #100DaysOfLeetCode 💻✅ Solved #145. Binary Tree Postorder Traversal on LeetCode using Java. Approach: • Used recursion to perform postorder traversal • Followed Left → Right → Root order strictly • Traversed left subtree first • Then traversed right subtree • Added node value after visiting both subtrees Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 43.12 MB (Beats 71.37% submissions) Key Learning: ✓ Clearly understood difference between preorder, inorder, and postorder ✓ Strengthened recursive tree traversal concepts ✓ Improved confidence in handling binary tree problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

Day 47 of #100DaysOfLeetCode 💻✅ Solved #101. Symmetric Tree problem in Java. Approach: • Used recursion to compare the left and right subtrees of the root • If both nodes are null, the tree is symmetric at that level • If one node is null and the other is not, the tree is not symmetric • Compared the values of both nodes • Recursively checked left.left with right.right and left.right with right.left to verify mirror structure Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.62 MB (Beats 48.60% submissions) Key Learning: ✓ Practiced mirror comparison in binary trees ✓ Learned how recursion can verify symmetry between two subtrees ✓ Strengthened understanding of tree traversal and structural comparison Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTrees #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Day 33 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Index Manipulation 🧩 Problem Solved: Shuffle the Array Problem: Given an array in the form [x1, x2, ..., xn, y1, y2, ..., yn], rearrange it to [x1, y1, x2, y2, ..., xn, yn]. Approach: Used two pointers to track elements from the first and second halves of the array, then alternately placed them into a new array to achieve the required shuffle pattern. Key Learning: ✔️ Managing multiple pointers in array problems ✔️ Practicing index-based rearrangement ✔️ Maintaining correct ordering while constructing a new array If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency

📌 Optimized Prime Number Check in Java (Time Complexity O(√n)) While practicing problem-solving, I implemented an optimized Prime Number check using mathematical reasoning instead of brute force. Instead of checking divisibility from 2 to n-1 (O(n)), I reduced the complexity to O(√n). 🔍 Key Optimizations Used: 1️⃣ Handle edge cases separately n == 1 → Not prime n == 2 or n == 3 → Prime 2️⃣ Eliminate obvious non-primes early If n % 2 == 0 or n % 3 == 0 → Not prime 3️⃣ Check only up to √n If a number n = a × b, then at least one of a or b must be ≤ √n. This reduces unnecessary computations significantly. ⏱ Complexity Analysis: • Time Complexity → O(√n) • Space Complexity → O(1) 💡 Why This Matters? Optimizing from O(n) to O(√n) shows: Strong mathematical thinking Better algorithm design Interview-level optimization skills Small improvements in complexity can make a huge difference for large inputs. #Java #DataStructures #Algorithms #ProblemSolving #TimeComplexity #CodingInterview #LearningJourney

🚀 Day 29 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Two-Pointer Technique 🧩 Problem Solved: Container With Most Water Problem: Given an array where each element represents the height of a vertical line, find two lines that together with the x-axis form a container that holds the maximum amount of water. Approach: Used a two-pointer strategy starting from both ends of the array. Calculated the water area using the shorter height and the distance between pointers, then moved the pointer with the smaller height to try finding a better container. Key Learning: ✔️ Efficient use of two-pointer technique ✔️ Understanding how pointer movement impacts optimization ✔️ Reducing brute-force O(n²) solutions to O(n) If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency

🚀 DSA in Java — Day 79 📌 Problem Solved: Sum Root to Leaf Numbers Today I solved the Sum Root to Leaf Numbers problem on LeetCode using Depth First Search (DFS) and Recursion. In this problem, each root-to-leaf path in a binary tree forms a number. The goal is to calculate the sum of all these numbers. 🔹 Approach Used: Used recursive DFS traversal Maintained a running number while moving from root to leaf At each step, updated the number using current = current * 10 + node.val When a leaf node is reached, added the number to the final sum 🔹 Key Concepts Practiced: ✔ Binary Trees ✔ Depth First Search (DFS) ✔ Recursion ✔ Tree Path Problems This problem improved my understanding of how recursion can be used to build values while traversing tree paths. Consistent practice is helping me become more comfortable with tree-based problems in DSA. #DSA #Java #BinaryTree #Recursion #LeetCode #CodingJourney #WomenInTech #100DaysOfCode