From 63586e0fa79cafd29c8df4179f6e0c99eeaaf61d Mon Sep 17 00:00:00 2001 From: Apurva1807 <24b01a12f4@svecw.edu.in> Date: Sat, 25 Oct 2025 13:42:16 +0530 Subject: [PATCH 1/4] Added Searching Algorithms in java --- .vscode/settings.json | 3 ++ SearchingAlgorithms/BinarySearch.java | 30 +++++++++++++ SearchingAlgorithms/ExponentialSearch.java | 43 ++++++++++++++++++ SearchingAlgorithms/InterpolationSearch.java | 38 ++++++++++++++++ SearchingAlgorithms/JumpSearch.java | 44 +++++++++++++++++++ SearchingAlgorithms/LinearSearch.class | Bin 0 -> 1157 bytes SearchingAlgorithms/LinearSearch.java | 22 ++++++++++ SearchingAlgorithms/TernarySearch.java | 37 ++++++++++++++++ 8 files changed, 217 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 SearchingAlgorithms/BinarySearch.java create mode 100644 SearchingAlgorithms/ExponentialSearch.java create mode 100644 SearchingAlgorithms/InterpolationSearch.java create mode 100644 SearchingAlgorithms/JumpSearch.java create mode 100644 SearchingAlgorithms/LinearSearch.class create mode 100644 SearchingAlgorithms/LinearSearch.java create mode 100644 SearchingAlgorithms/TernarySearch.java diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..c995aa5 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "java.debug.settings.onBuildFailureProceed": true +} \ No newline at end of file diff --git a/SearchingAlgorithms/BinarySearch.java b/SearchingAlgorithms/BinarySearch.java new file mode 100644 index 0000000..7281827 --- /dev/null +++ b/SearchingAlgorithms/BinarySearch.java @@ -0,0 +1,30 @@ +package SearchingAlgorithms; + +public class BinarySearch { + public static int binarySearch(int[] arr, int target) { + int left = 0, right = arr.length - 1; + while (left <= right) { + int mid = left + (right - left) / 2; + + if (arr[mid] == target) + return mid; + if (arr[mid] < target) + left = mid + 1; + else + right = mid - 1; + } + return -1; + } + + public static void main(String[] args) { + int[] arr = {10, 20, 30, 40, 50}; + int target = 40; + + int result = binarySearch(arr, target); + if (result != -1) + System.out.println("Element found at index: " + result); + else + System.out.println("Element not found"); + } +} + diff --git a/SearchingAlgorithms/ExponentialSearch.java b/SearchingAlgorithms/ExponentialSearch.java new file mode 100644 index 0000000..6588c1d --- /dev/null +++ b/SearchingAlgorithms/ExponentialSearch.java @@ -0,0 +1,43 @@ +package SearchingAlgorithms; + +public class ExponentialSearch { + public static void main(String[] args) { + int[] arr = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; + int target = 14; + int result = exponentialSearch(arr, target); + + if (result == -1) + System.out.println("Element not found"); + else + System.out.println("Element found at index: " + result); + } + + static int exponentialSearch(int[] arr, int target) { + int n = arr.length; + + // If the target is at first index + if (arr[0] == target) + return 0; + + // Find range for binary search by repeated doubling + int i = 1; + while (i < n && arr[i] <= target) + i = i * 2; + + // Call binary search for the found range + return binarySearch(arr, i / 2, Math.min(i, n - 1), target); + } + + static int binarySearch(int[] arr, int left, int right, int target) { + while (left <= right) { + int mid = left + (right - left) / 2; + if (arr[mid] == target) + return mid; + if (arr[mid] < target) + left = mid + 1; + else + right = mid - 1; + } + return -1; + } +} diff --git a/SearchingAlgorithms/InterpolationSearch.java b/SearchingAlgorithms/InterpolationSearch.java new file mode 100644 index 0000000..4557455 --- /dev/null +++ b/SearchingAlgorithms/InterpolationSearch.java @@ -0,0 +1,38 @@ +package SearchingAlgorithms; +public class InterpolationSearch { + public static void main(String[] args) { + int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; + int target = 70; + int result = interpolationSearch(arr, target); + + if (result == -1) + System.out.println("Element not found"); + else + System.out.println("Element found at index: " + result); + } + + static int interpolationSearch(int[] arr, int target) { + int low = 0, high = arr.length - 1; + + while (low <= high && target >= arr[low] && target <= arr[high]) { + // Avoid division by zero + if (arr[low] == arr[high]) { + if (arr[low] == target) + return low; + else + return -1; + } + + // Estimate position using interpolation formula + int pos = low + ((target - arr[low]) * (high - low)) / (arr[high] - arr[low]); + + if (arr[pos] == target) + return pos; + if (arr[pos] < target) + low = pos + 1; + else + high = pos - 1; + } + return -1; + } +} diff --git a/SearchingAlgorithms/JumpSearch.java b/SearchingAlgorithms/JumpSearch.java new file mode 100644 index 0000000..e22e213 --- /dev/null +++ b/SearchingAlgorithms/JumpSearch.java @@ -0,0 +1,44 @@ +package SearchingAlgorithms; + +public class JumpSearch { + public static void main(String[] args) { + int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; + int target = 13; + int result = jumpSearch(arr, target); + + if (result == -1) + System.out.println("Element not found"); + else + System.out.println("Element found at index: " + result); + } + + static int jumpSearch(int[] arr, int target) { + int n = arr.length; + + // Finding block size to jump + int step = (int)Math.floor(Math.sqrt(n)); + int prev = 0; + + // Jump ahead while the last element of block < target + while (arr[Math.min(step, n) - 1] < target) { + prev = step; + step += (int)Math.floor(Math.sqrt(n)); + if (prev >= n) + return -1; + } + + // Linear search in the found block + while (arr[prev] < target) { + prev++; + if (prev == Math.min(step, n)) + return -1; + } + + // If element is found + if (arr[prev] == target) + return prev; + + return -1; + } +} + diff --git a/SearchingAlgorithms/LinearSearch.class b/SearchingAlgorithms/LinearSearch.class new file mode 100644 index 0000000000000000000000000000000000000000..916a3c912666328382547437214334115a801f06 GIT binary patch literal 1157 zcmaJ=-A)rx5dO~gXWOOFrTmGswJ2a)lq&uuR7kLq*rZrZ38vxd&>mswcDLC*C34S0 zc&G7(8*cPM4KX}`590$EgU+@XOK8ky_sqIzx2tQsCT-_{;cag# z&KLG zde@$7*xMD7J=d4sy3sl5TaIT>KOmNkFHF5hAbxzPu%q8Ulw-P7I^pA#fiNj&5K*YK zC;?0m*fd!+_(Q-AQC(G5Ko-S8aeX(59 zlgsn*uTWPK$~(k9VK8xm5#Tc>jxa!KEJ31IN0&&Fk^_TO<`5CnF-KJ95yKKj@q{MG nBQyZz3`;6z7*nahxlZs+r0EP1w|ROqxJ#Nw(jxBTAtwI-!lxDi literal 0 HcmV?d00001 diff --git a/SearchingAlgorithms/LinearSearch.java b/SearchingAlgorithms/LinearSearch.java new file mode 100644 index 0000000..663650c --- /dev/null +++ b/SearchingAlgorithms/LinearSearch.java @@ -0,0 +1,22 @@ +package SearchingAlgorithms; + +public class LinearSearch { + public static int linearSearch(int[] arr, int target) { + for (int i = 0; i < arr.length; i++) { + if (arr[i] == target) + return i; + } + return -1; + } + + public static void main(String[] args) { + int[] arr = {10, 20, 30, 40, 50}; + int target = 30; + + int result = linearSearch(arr, target); + if (result != -1) + System.out.println("Element found at index: " + result); + else + System.out.println("Element not found"); + } +} diff --git a/SearchingAlgorithms/TernarySearch.java b/SearchingAlgorithms/TernarySearch.java new file mode 100644 index 0000000..10ec740 --- /dev/null +++ b/SearchingAlgorithms/TernarySearch.java @@ -0,0 +1,37 @@ +package SearchingAlgorithms; + +public class TernarySearch { + public static void main(String[] args) { + int[] arr = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}; + int target = 16; + int result = ternarySearch(arr, 0, arr.length - 1, target); + + if (result == -1) + System.out.println("Element not found"); + else + System.out.println("Element found at index: " + result); + } + + static int ternarySearch(int[] arr, int left, int right, int target) { + if (right >= left) { + // Split the range into 3 parts + int mid1 = left + (right - left) / 3; + int mid2 = right - (right - left) / 3; + + // Check if target is at any mid + if (arr[mid1] == target) + return mid1; + if (arr[mid2] == target) + return mid2; + + // Recur in left or right part + if (target < arr[mid1]) + return ternarySearch(arr, left, mid1 - 1, target); + else if (target > arr[mid2]) + return ternarySearch(arr, mid2 + 1, right, target); + else + return ternarySearch(arr, mid1 + 1, mid2 - 1, target); + } + return -1; + } +} From d8fe639da85faa55208326b1245d5593dc108ad2 Mon Sep 17 00:00:00 2001 From: Apurva1807 <24b01a12f4@svecw.edu.in> Date: Sat, 25 Oct 2025 13:46:45 +0530 Subject: [PATCH 2/4] Removed compiled class file --- SearchingAlgorithms/LinearSearch.class | Bin 1157 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 SearchingAlgorithms/LinearSearch.class diff --git a/SearchingAlgorithms/LinearSearch.class b/SearchingAlgorithms/LinearSearch.class deleted file mode 100644 index 916a3c912666328382547437214334115a801f06..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1157 zcmaJ=-A)rx5dO~gXWOOFrTmGswJ2a)lq&uuR7kLq*rZrZ38vxd&>mswcDLC*C34S0 zc&G7(8*cPM4KX}`590$EgU+@XOK8ky_sqIzx2tQsCT-_{;cag# z&KLG zde@$7*xMD7J=d4sy3sl5TaIT>KOmNkFHF5hAbxzPu%q8Ulw-P7I^pA#fiNj&5K*YK zC;?0m*fd!+_(Q-AQC(G5Ko-S8aeX(59 zlgsn*uTWPK$~(k9VK8xm5#Tc>jxa!KEJ31IN0&&Fk^_TO<`5CnF-KJ95yKKj@q{MG nBQyZz3`;6z7*nahxlZs+r0EP1w|ROqxJ#Nw(jxBTAtwI-!lxDi From bc2d5ee71720632d0a429f62bb5c26170ef5aa26 Mon Sep 17 00:00:00 2001 From: Apurva1807 <24b01a12f4@svecw.edu.in> Date: Sat, 25 Oct 2025 14:36:46 +0530 Subject: [PATCH 3/4] Added Longest Subarray with Sum K program in Java --- LongestSubarraySumK.java | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 LongestSubarraySumK.java diff --git a/LongestSubarraySumK.java b/LongestSubarraySumK.java new file mode 100644 index 0000000..1845130 --- /dev/null +++ b/LongestSubarraySumK.java @@ -0,0 +1,37 @@ +import java.util.*; +public class LongestSubarraySumK +{ + public static int longestSubarrayWithSumK(int[] arr, int k) { + Map prefixSumMap = new HashMap<>(); + int sum = 0, maxLen = 0; + for (int i = 0; i < arr.length; i++) { + sum += arr[i]; + // If sum equals K, whole array till i has sum K + if (sum == k) { + maxLen = i + 1; + } + if (prefixSumMap.containsKey(sum - k)) { + maxLen = Math.max(maxLen, i - prefixSumMap.get(sum - k)); + } + // Store sum if it's not already present + prefixSumMap.putIfAbsent(sum, i); + } + return maxLen; + } + public static void main(String[] args) + { + Scanner sc = new Scanner(System.in); + System.out.println("Enter array size:"); + int n = sc.nextInt(); + int[] a = new int[n]; + System.out.println("Enter array elements:"); + for (int i = 0; i < n; i++) { + a[i] = sc.nextInt(); + } + System.out.println("Enter K:"); + int k = sc.nextInt(); + int result = longestSubarrayWithSumK(a, k); + System.out.println("Length of longest subarray with sum " + k + " is: " + result); + } +} + From 0bda41d2e39f3e4866c2f80793b8c6281829e745 Mon Sep 17 00:00:00 2001 From: Apurva1807 <24b01a12f4@svecw.edu.in> Date: Sat, 25 Oct 2025 14:52:40 +0530 Subject: [PATCH 4/4] Added Longest Subarray with Sum K program in Java --- SearchingAlgorithms/LinearSearch.class | Bin 0 -> 1157 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 SearchingAlgorithms/LinearSearch.class diff --git a/SearchingAlgorithms/LinearSearch.class b/SearchingAlgorithms/LinearSearch.class new file mode 100644 index 0000000000000000000000000000000000000000..916a3c912666328382547437214334115a801f06 GIT binary patch literal 1157 zcmaJ=-A)rx5dO~gXWOOFrTmGswJ2a)lq&uuR7kLq*rZrZ38vxd&>mswcDLC*C34S0 zc&G7(8*cPM4KX}`590$EgU+@XOK8ky_sqIzx2tQsCT-_{;cag# z&KLG zde@$7*xMD7J=d4sy3sl5TaIT>KOmNkFHF5hAbxzPu%q8Ulw-P7I^pA#fiNj&5K*YK zC;?0m*fd!+_(Q-AQC(G5Ko-S8aeX(59 zlgsn*uTWPK$~(k9VK8xm5#Tc>jxa!KEJ31IN0&&Fk^_TO<`5CnF-KJ95yKKj@q{MG nBQyZz3`;6z7*nahxlZs+r0EP1w|ROqxJ#Nw(jxBTAtwI-!lxDi literal 0 HcmV?d00001