Skip to main content

Searching

 

Searching is a process of finding an item or group of items that match certain criteria within a data structure, such as an array or linked list. There are various search algorithms with varying time complexity, including linear search, binary search, and hash table search.

Linear search goes through each element in the data structure sequentially until a match is found. Binary search divides the data structure in half with each iteration and only searches the half that could contain the item. Hash table search uses a hash function to map data to an index in an array and directly access the desired item.

The efficiency of a search algorithm depends on the size of the data structure and the distribution of the data. Sorted data structures make binary search faster, while unsorted data makes linear search faster. Hash tables are efficient for searching large data sets with a good hash function.

In programming, searching is an important operation that is used in many applications, such as databases, search engines, and e-commerce websites. The choice of search algorithm often depends on the specific requirements of the application and trade-offs between time and space complexity.


TYPES OF SEARCHING ALGORITHMS :

  1. Linear Search
  2. Binary Search
  3. Depth First Search (DFS)
  4. Breadth First Search (BFS)
  5. Rabin-Karp Algorithm
  6. Z- Algorithm

QUESTIONS ON SEARCHING ALGORITHMS :

  1. Linear Search
  2. Binary Search
  3. Depth First Search (DFS)
  4. Breadth First Search (BFS)
  5. Rabin-Karp Algorithm
  6. Z- Algorithm

Comments

Popular posts from this blog

Leetcode 1: Two Sum

  Leetcode Link: https://leetcode.com/problems/two-sum/ 1. Problem Statement (Simple Explanation) You are given: An array of integers nums An integer target You need to  return the indices of two numbers in the array  such that: Conditions: Each input has  exactly one solution . You  cannot use the same element twice . You can return the answer in  any order . 2. Examples Example 1 Input:                                    nums = [2, 7, 11, 15], target = 9 Output:                                 [0, 1] Explanation:                     nums[0]+nums[1]=2+7=9              So we return [0, 1]. Example 2 Input:           ...

Leetcode 3: Longest Substring Without Repeating Characters

  Leetcode Link 1. Problem Statement (Simple Explanation) You are given a string s. You need to find the length of the longest substring of s that does not  contain any repeated characters. A substring is a contiguous sequence of characters in the string. You must return an integer length, not the substring itself. 2. Examples Example 1 Input: s = "abcabcbb" Output: 3 Explanation: Some substrings without repeating characters: "abc", "bca", "cab"The longest length is 3. Example 2 Input: s = "bbbbb" Output: 1 Explanation: All substrings that are valid are just "b". The longest length is 1. Example 3 Input:   s = "pwwkew" Output:   3 Explanation: Possible substrings without repetition: "pw", "wke", "kew". "wke" or "kew" have length 3. "pwke" is not valid because it’s not contiguous in the original string (p and k are separated by ww). Constraints...

Leetcode 2: Add Two Numbers

Leetcode Link: https://leetcode.com/problems/add-two-numbers/ 1. Problem Statement (Simple Explanation) You are given  two non-empty linked lists , l1 and l2, that represent two non-negative integers. Each node contains a  single digit . The digits are stored in  reverse order  (i.e., the 1’s digit is at the head). You need to  add the two numbers  and return the  sum as a linked list , also in reverse order. You can assume: There are  no leading zeros , except when the number itself is 0. 2. Examples Example 1 Input:                l1 = [2,4,3]                l2 = [5,6,4]           Interpreting linked lists as numbers (reverse order): l1 represents 342 l2 represents 465 Output:                [7,0,8] Explanation:        ...