Arrays

0001_TwoSum_BruteForce.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int n = nums.length;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[] {i, j};
+                }
+            }
+        }
+        return new int[] {}; 
+    }
+}

0011_Container_With_Most_Water.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+        int maxArea = 0;
+
+        while (left < right) {
+            int width = right - left;
+            int minHeight = Math.min(height[left], height[right]);
+            int area = width * minHeight;
+
+            maxArea = Math.max(maxArea, area);
+
+            // Move the pointer with smaller height
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return maxArea;
+    }
+}

0026_Remove_Duplicates_from_Sorted_Array.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        if (nums.length == 0) return 0;
+
+        int i = 0; // slow pointer
+
+        for (int j = 1; j < nums.length; j++) {
+            if (nums[j] != nums[i]) {
+                i++;
+                nums[i] = nums[j];
+            }
+        }
+
+        return i + 1; // number of unique elements
+    }
+}

0053_Maximum_Subarray.java

@@ -0,0 +1,13 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int max_sum = nums[0];
+        int current_sum = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            current_sum = Math.max(nums[i], current_sum + nums[i]);
+            max_sum = Math.max(max_sum, current_sum);
+        }
+
+        return max_sum;
+    }
+}

0075_Sort_Colors.java

@@ -0,0 +1,26 @@
+class Solution {
+    public void sortColors(int[] nums) {
+        int low = 0;
+        int mid = 0;
+        int high = nums.length - 1;
+
+        while (mid <= high) {
+            if (nums[mid] == 0) {
+                int temp = nums[low];
+                nums[low] = nums[mid];
+                nums[mid] = temp;
+                low++;
+                mid++;
+            } 
+            else if (nums[mid] == 1) {
+                mid++;
+            } 
+            else { // nums[mid] == 2
+                int temp = nums[high];
+                nums[high] = nums[mid];
+                nums[mid] = temp;
+                high--;
+            }
+        }
+    }
+}

0088_Merge_Sorted_Array.java

@@ -0,0 +1,27 @@
+class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+
+        int i = m - 1;          // Pointer for nums1
+        int j = n - 1;          // Pointer for nums2
+        int k = m + n - 1;      // Pointer for final position
+
+        // Merge from the back
+        while (i >= 0 && j >= 0) {
+            if (nums1[i] > nums2[j]) {
+                nums1[k] = nums1[i];
+                i--;
+            } else {
+                nums1[k] = nums2[j];
+                j--;
+            }
+            k--;
+        }
+
+        // If nums2 still has elements left
+        while (j >= 0) {
+            nums1[k] = nums2[j];
+            j--;
+            k--;
+        }
+    }
+}

0121_Best_Time_to_Buy_and_Sell_Stock.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+
+        int profit = 0 ;
+        int n = prices.length;
+        int min_price = prices[0];
+        for(int i = 0; i<n ; i++)
+        {
+            min_price = Math.min(min_price,prices[i]);
+            profit = Math.max(profit,prices[i]-min_price);
+        }
+        return profit ;
+
+    }
+}

0268_Missing_Number.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+
+        int expectedSum = n * (n + 1) / 2;
+        int actualSum = 0;
+
+        for (int num : nums) {
+            actualSum += num;
+        }
+
+        return expectedSum - actualSum;
+    }
+}

0283_Move_Zeroes.java

@@ -0,0 +1,19 @@
+class Solution {
+    public void moveZeroes(int[] nums) {
+        int insertPos = 0;  // position to place next non-zero
+
+        // Move all non-zero elements to the front
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[insertPos] = nums[i];
+                insertPos++;
+            }
+        }
+
+        // Fill the remaining positions with zeros
+        while (insertPos < nums.length) {
+            nums[insertPos] = 0;
+            insertPos++;
+        }
+    }
+}

0704_Binary_Search.java

@@ -0,0 +1,26 @@
+class Solution {
+    public int search(int[] nums, int target) {
+
+        int low = 0;
+        int high = nums.length - 1;
+
+        while (low <= high) {
+
+            int mid = low + (high - low) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            } 
+            else if (nums[mid] < target) {
+                low = mid + 1;
+            } 
+            else {
+                high = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+}
+
+

README.md

@@ -1,2 +1,106 @@
-# LeetCode-DSA-Practice
-A collection of my LeetCode problem solutions written in Java. This repository documents my journey of practicing Data Structures and Algorithms for coding interviews and competitive programming. Each solution focuses on optimized time and space complexity.
+# Arrays
+
+## 1. Two Sum
+Problem Link: https://leetcode.com/problems/two-sum/
+Difficulty: Easy
+### Approach : Brute Force
+Time Complexity: O(n²)
+Space Complexity: O(1)
+### Concepts Used:
+Array Traversal,Nested Loops,Pair Checking
+
+### Approach 2: HashMap (Optimized)
+Time Complexity: O(n)
+Space Complexity: O(n)
+### Concepts Used:
+Array Traversal,HashMap,Complement Technique,Single Pass Algorithm,Key-Value Mapping
+
+## 11. Container With Most Water
+Problem Link: https://leetcode.com/problems/container-with-most-water/
+Difficulty: Medium
+### Approach: Two Pointers (Greedy Optimization)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Two Pointers, Greedy Strategy, Area Calculation, Width–Height Optimization, Pointer Movement Logic
+
+## 26. Remove Duplicates from Sorted Array
+Problem Link: https://leetcode.com/problems/remove-duplicates-from-sorted-array/
+Difficulty: Easy
+### Approach: Two Pointer Technique (Optimized)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Two Pointer Technique, In-Place Modification, Sorted Array Property, Single Pass Algorithm
+
+## 53. Maximum Subarray
+Problem Link: https://leetcode.com/problems/maximum-subarray/
+Difficulty: Medium
+### Approach: Kadane’s Algorithm (Dynamic Programming / Greedy)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Kadane’s Algorithm, Dynamic Programming, Greedy Strategy, Running Sum, Maximum Tracking
+
+## 75. Sort Colors
+Problem Link: https://leetcode.com/problems/sort-colors/
+Difficulty: Medium
+### Approach: Dutch National Flag Algorithm (Three Pointers)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Three Pointers, Two Pointer Technique, In-Place Sorting, Partitioning Logic, Dutch National Flag Algorithm
+
+## 88. Merge Sorted Array
+Problem Link: https://leetcode.com/problems/merge-sorted-array/
+Difficulty: Easy
+### Approach: Two Pointers (Backward Merge)
+Time Complexity: O(m + n)
+Space Complexity: O(1)
+### Concepts Used:
+Two Pointers, Array Traversal, In-Place Algorithm, Backward Iteration, Merging Technique
+
+## 121. Best Time to Buy and Sell Stock
+Problem Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+Difficulty: Easy
+### Approach: Greedy (One Pass Optimization)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Array Traversal,Greedy Strategy,Minimum Tracking,Profit Maximization,Single Pass Algorithm
+
+## 128. Longest Consecutive Sequence
+Problem Link: https://leetcode.com/problems/longest-consecutive-sequence/
+Difficulty: Medium
+### Approach: HashSet (Optimized)
+Time Complexity: O(n)
+Space Complexity: O(n)
+### Concepts Used:
+HashSet, Sequence Pattern, Array Traversal
+
+## 268. Missing Number
+Problem Link: https://leetcode.com/problems/missing-number/
+Difficulty: Easy
+### Approach: Mathematical Formula (Sum Formula)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Mathematical Formula, Arithmetic Series, Array Traversal, Summation Technique
+
+## 283. Move Zeroes
+Problem Link: https://leetcode.com/problems/move-zeroes/
+Difficulty: Easy
+### Approach: Two Pointers (In-Place Modification)
+Time Complexity: O(n)
+Space Complexity: O(1)
+### Concepts Used:
+Two Pointers, Array Traversal, In-Place Algorithm, Element Shifting, Stable Partitioning
+
+## 704. Binary Search
+Problem Link: https://leetcode.com/problems/binary-search/
+Difficulty: Easy
+### Approach: Binary Search (Optimized)
+Time Complexity: O(log n)
+Space Complexity: O(1)
+### Concepts Used:
+Divide and Conquer,Sorted Array Requirement,Two Pointers (Low & High),Mid Calculation,Half Search Space Reduction