Search Algorithm

Author: piyush-eon

#7 - Search Algorithm/1-linear-search.js

@@ -0,0 +1,37 @@
+// Ques 1: Implement Linear Search in JavaScript
+// Write a function to search "target" in nums. If target exists, then return its index.
+// Otherwise, return -1. You must write an algorithm with O(n) runtime complexity.
+
+// Input: nums = [4,5,6,7,0,1,2], target = 0  ----->>>>>  Output:  4
+// Input: nums = [4,5,6,7,0,1,2], target = 3  ----->>>>>  Output: -1
+
+const linearSearch = (nums, target) => {
+  for (let i = 0; i < nums.length; i++) {
+    if (target === nums[i]) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+// Time Complexity  - O(n)
+// Space Complexity - O(1)
+// console.log(linearSearch([4, 5, 6, 7, 0, 1, 2], 0));
+// console.log(linearSearch([4, 5, 6, 7, 0, 1, 2], 3));
+
+// Global Linear Search
+
+const globalLinearSearch = (nums, target) => {
+  const result = [];
+  for (let i = 0; i < nums.length; i++) {
+    if (target === nums[i]) {
+      result.push(i);
+    }
+  }
+  if (result.length === 0) return -1;
+  return result;
+};
+
+// Time Complexity  - O(n)
+// Space Complexity - O(n)
+console.log(globalLinearSearch([4, 5, 0, 7, 0, 1, 2], 0));

#7 - Search Algorithm/2-binary-search.js

@@ -0,0 +1,31 @@
+// Ques 2: Implement Binary Search in JavaScript
+// Given an array of integers nums which is sorted in ascending order, and an integer target,
+// Write a function to search target in nums. If target exists, then return its index.
+// Otherwise, return -1. You must write an algorithm with O(log n) runtime complexity.
+
+// Input: nums = [-1,0,3,5,9,12], target = 9  ----->>>>>  Output:  4
+// Input: nums = [-1,0,3,5,9,12], target = 2  ----->>>>>  Output: -1
+
+function search(nums, target) {
+  let start = 0;
+  let end = nums.length - 1;
+
+  while (start <= end) {
+    let middle = Math.floor((start + end) / 2);
+
+    if (nums[middle] === target) {
+      return middle;
+    } else if (nums[middle] < target) {
+      start = middle + 1;
+    } else {
+      end = middle - 1;
+    }
+  }
+
+  return -1;
+}
+
+// Time Complexity  - O(logn)
+// Space Complexity - O(1)
+console.log(search([-1, 0, 3, 5, 9, 12], 9));
+console.log(search([-1, 0, 3, 5, 9, 12], 69));

#7 - Search Algorithm/3-kth-missing-positive-number.js

@@ -0,0 +1,23 @@
+// Ques 3: Kth Missing Positive Number
+// Given an array arr of positive integers sorted in a strictly increasing order,
+// and an integer k. Return the kth positive integer that is missing from this array.
+
+// Input: arr = [2,3,4,7,11], k = 5  ----->>>>>  Output: 9
+// Explanation: The missing positive integers are [1,5,6,8,9,10,12,13,...].
+//              The 5th missing positive integer is 9.
+
+// arr = [2,3,4,7,11], k = 5
+// count = 4
+// 11 <= 9
+function findKthPositive(arr, k) {
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] <= k + count) {
+      count++;
+    }
+  }
+
+  return k + count;
+}
+
+console.log(findKthPositive([2, 3, 4, 7, 11], 5));

#7 - Search Algorithm/4-maximum-count-of-positive-and-negative-integer.js

@@ -0,0 +1,42 @@
+// Ques 4: Maximum Count of Positive Integer and Negative Integer
+// Given an array nums sorted in non-decreasing order, return the maximum between
+// the number of positive integers and the number of negative integers.
+
+// Input: nums = [-2,-1,-1,1,2,3]  ----->>>>>  Output: 3
+// Explanation: There are 3 positive integers and 3 negative integers.
+//              The maximum count among them is 3.
+
+function maximumCount(nums) {
+  return Math.max(upperBound(nums), lowerBound(nums));
+}
+
+// [-2,-1,-1,1,2,3]
+// low = 2 , high = 2
+// mid = 3 => nums[3] = 1
+function upperBound(nums) {
+  let low = 0,
+    high = nums.length - 1;
+
+  while (low < high) {
+    let mid = Math.ceil((low + high) / 2);
+    if (nums[mid] < 0) low = mid;
+    else high = mid - 1;
+  }
+
+  return nums[0] >= 0 ? 0 : low + 1;
+}
+
+function lowerBound(nums) {
+  let low = 0,
+    high = nums.length - 1;
+
+  while (low < high) {
+    let mid = Math.floor((low + high) / 2);
+    if (nums[mid] > 0) high = mid;
+    else low = mid + 1;
+  }
+
+  return nums[nums.length - 1] <= 0 ? 0 : nums.length - low;
+}
+
+console.log(maximumCount([-2, -1, -1, 1, 2, 3]));