Java Linear Search Algorithm Implementation

🚀 Day 37 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Two-Pointer Technique 🧩 Problem Solved: Squares of a Sorted Array Problem: Given a sorted array of integers (including negatives), return a new array of the squares of each number, also sorted in non-decreasing order. Approach: Used a two-pointer approach from both ends of the array. Compared squares of elements and filled the result array from the end to maintain sorted order efficiently. Key Learning: ✔️ Handling negative values in sorted arrays ✔️ Using two-pointer technique for optimal solutions ✔️ Avoiding extra sorting to achieve O(n) time complexity If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency 

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

Leveling up my searching algorithms! Today’s Java DSA topic: Binary Search. After exploring the brute-force nature of Linear Search, moving to Binary Search. Instead of checking every single element one by one O(n), Binary Search slashes the time complexity to O(log n). The catch? The array must be sorted first! (Good thing I just covered sorting algorithms). The logic is brilliant and incredibly efficient: 1. Find the middle element. 2. If it matches the target, you're done! 3. If the target is smaller, discard the right half. If larger, discard the left. 4. Repeat. #DSA #Java #BinarySearch

Shifting from Sorting to Searching in Java DSA! After learning sorting algorithm from basics to complex like recursion of Quick and Merge sort, today I started searching algorithm like Linear Search. It is as straightforward as it gets: 1. Start at the beginning of the array. 2.Check every single element one by one. 3. Stop when you find the target. With a time complexity of O(n), it isn't the most efficient algorithm for massive datasets. However, it doesn't require the array to be sorted first, which makes it a great reminder that sometimes a simple, brute-force approach is exactly what you need for small, unsorted data. #DSA #Java #LinearSearch

🚀 Day 36 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Search (Peak Finding) 🧩 Problem Solved: Find Peak Element Problem: Given an array, find a peak element (an element greater than its neighbors) and return its index. Approach: Used Binary Search by comparing the middle element with its neighbors. Based on the increasing or decreasing slope, moved towards the side where a peak must exist, reducing the search space efficiently. Key Learning: ✔️ Applying binary search on unsorted arrays using patterns ✔️ Understanding how slope direction guides decisions ✔️ Solving peak problems in O(log n) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #BinarySearch #ProblemSolving #Consistency

‎🚀 Day 16/105 – Java + DSA Journey ‎ ‎Today I explored the fundamentals of Sorting Algorithms in Java. ‎ ‎📌 Topics Covered: ‎• What is Sorting ‎• Bubble Sort ‎• Selection Sort ‎• Insertion Sort ‎ ‎Understanding these basic sorting techniques helped me build a strong foundation in data organization and algorithm thinking. Each algorithm has its own approach and efficiency, which makes problem-solving more interesting. ‎ ‎Consistently improving my DSA skills step by step 💻 ‎ ‎#Java #DSA #105DaysChallenge #PlacementPreparation #LearningInPublic #Consistency #DSABasicFundamentals #ApnaCollege #RajTech #Day16

🚀 Day 40 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Exponentiation (Fast Power) 🧩 Problem Solved: Pow(x, n) Problem: Implement a function to calculate x raised to the power n, handling both positive and negative values of n. Approach: Used Binary Exponentiation to reduce time complexity. Repeatedly squared the base and halved the exponent, multiplying the result only when needed. Also handled negative powers by taking the reciprocal. Key Learning: ✔️ Optimizing from O(n) to O(log n) ✔️ Understanding divide-and-conquer in exponentiation ✔️ Handling edge cases like negative powers If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #ProblemSolving #Consistency 

🚀 Day 40 of My Java DSA Journey Today I worked on an interesting Binary Tree problem: 🌳 Flatten Binary Tree to Linked List 💡 Problem idea: Convert a binary tree into a linked list (in-place) following preorder traversal. 🔍 Approach I used: • Performed preorder traversal (Root → Left → Right) • Stored nodes in a list • Reconnected nodes such that: Left pointer → null Right pointer → next node in preorder ⚡ Key Learning: Understanding traversal order is crucial — preorder ensures the correct sequence for flattening. 🔥 What improved today: • Tree traversal skills • Pointer manipulation • Converting tree structure into linear form 🎯 Takeaway: Complex transformations become easier when broken into simple traversal steps. #Day40 #90DaysOfCoding #Java #DSA #BinaryTree #Recursion #Preorder #ProblemSolving

🚀 Day 45 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Two-Pointer Technique 🧩 Problem Solved: Merge Sorted Array Problem: Given two sorted arrays, merge the second array into the first one as a single sorted array. Approach: Started comparing elements from the end of both arrays and filled the first array from the last position backwards. This avoided shifting elements and enabled an efficient in-place merge. Key Learning: ✔️ Using reverse traversal for in-place operations ✔️ Applying two-pointer technique effectively ✔️ Merging sorted data in O(m + n) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency

Mastering Java & DSA Through LeetCode Day 34 Today I solved a Medium-level Tree problem that strengthened my understanding of Prefix Sum + DFS — a powerful pattern used in many interview questions. LeetCode Problem: 437. Path Sum III Problem Summary: Given a binary tree and a target sum, we need to find the number of paths where the sum of node values equals the target. The path must go downward (parent → child), but it doesn’t need to start from the root. Key Insight: Instead of checking all possible paths (which is inefficient), we use: Prefix Sum HashMap to store frequencies DFS traversal This helps reduce time complexity from O(n²) → O(n) ⚡ Approach: Maintain a running sum while traversing the tree Check if (currentSum - target) exists in the map Use backtracking to maintain correct state What I Learned: How prefix sum works in trees (not just arrays!) Optimizing brute-force solutions Importance of hashmap in reducing complexity Consistency Update: Day 34 of solving DSA problems daily 💪 Small steps every day = big results over time #LeetCode #Java #DSA #CodingJourney #100DaysOfCode #SoftwareEngineering #PlacementPreparation #CodingInterview