diff --git a/assets/LinearSearch_GFG.webp b/assets/LinearSearch_GFG.webp new file mode 100644 index 000000000..a8d1c4a40 Binary files /dev/null and b/assets/LinearSearch_GFG.webp differ diff --git a/assets/binnary-search-.webp b/assets/binnary-search-.webp new file mode 100644 index 000000000..a7fcaedf2 Binary files /dev/null and b/assets/binnary-search-.webp differ diff --git a/dsa-solutions/Searching-Algorithms/01-Linear-Search.md b/dsa-solutions/Searching-Algorithms/01-Linear-Search.md new file mode 100644 index 000000000..d5a5ecf34 --- /dev/null +++ b/dsa-solutions/Searching-Algorithms/01-Linear-Search.md @@ -0,0 +1,167 @@ +--- +id: Linear-Search +title: Linear Search (Geeks for Geeks) +sidebar_label: Linear Search +tags: + - Beginner + - Search Algorithms + - Geeks for Geeks + - CPP + - Python + - Java + - JavaScript + - DSA +description: "This is a solution to the Linear Search problem on Geeks for Geeks." +--- + +## What is Linear Search? + +Linear Search is a simple search algorithm used to find the presence of a target element within a list. It sequentially checks each element of the list until the target element is found or the list ends. + +## Algorithm for Linear Search + +1. Start from the leftmost element of the list and move towards the right. +2. Compare the target element with each element of the list. +3. If the target element matches with an element, return the index. +4. If the target element does not match any element, return -1. + +## How does Linear Search work? + +- It starts from the first element and compares the target element with each element in the list. +- If a match is found, it returns the index of the matching element. +- If no match is found after checking all elements, it returns -1 indicating the target is not present in the list. +![Example for Linear Search (GFG) ](../../assets/LinearSearch_GFG.webp) + +## Problem Description + +Given a list and a target element, implement the Linear Search algorithm to find the index of the target element in the list. If the element is not present, return -1. + +## Examples + +**Example 1:** +``` +Input: +list = [1, 3, 5, 7, 9] +target = 5 +Output: 2 +``` + +**Example 2:** +``` +Input: +list = [2, 4, 6, 8, 10] +target = 7 +Output: -1 +``` +## Your task + +Complete the function search() which takes two integers n , k and an array arr, as input parameters and returns an integer denoting the answer. Return -1 if the number is not found in the array. You don't have to print answers or take inputs. + +Expected Time Complexity: $O(n)$ +Expected Auxiliary Space: $O(1)$ + +## Constraints + +- $1 <= n <= 10^6$ +- $1 <= k <= 10^6$ +- $1 <= arr[i] <= 10^9$ + +## Implementation + + + + + ```python + def linear_search(lst, target): + for i in range(len(lst)): + if lst[i] == target: + return i + return -1 + ``` + + + + + ```cpp + #include + #include + + int linear_search(const std::vector& lst, int target) { + for (int i = 0; i < lst.size(); i++) { + if (lst[i] == target) { + return i; + } + } + return -1; + } + + int main() { + std::vector lst = {1, 3, 5, 7, 9}; + int target = 5; + std::cout << "Index: " << linear_search(lst, target) << std::endl; + return 0; + } + ``` + + + + + ```java + public class LinearSearch { + public static int linearSearch(int[] lst, int target) { + for (int i = 0; i < lst.length; i++) { + if (lst[i] == target) { + return i; + } + } + return -1; + } + + public static void main(String[] args) { + int[] lst = {1, 3, 5, 7, 9}; + int target = 5; + System.out.println("Index: " + linearSearch(lst, target)); + } + } + ``` + + + + + ```javascript + function linearSearch(lst, target) { + for (let i = 0; i < lst.length; i++) { + if (lst[i] === target) { + return i; + } + } + return -1; + } + + const lst = [1, 3, 5, 7, 9]; + const target = 5; + console.log("Index:", linearSearch(lst, target)); + ``` + + + +## Complexity Analysis + +- **Time Complexity**: $O(n)$, where $n$ is the number of elements in the list. In the worst case, it will search through the entire list. +- **Space Complexity**: $O(1)$, as no extra space is required apart from the input list. + +## Advantages and Disadvantages + +**Advantages:** +- Simple and easy to implement. +- Does not require the list to be sorted. + +**Disadvantages:** +- Inefficient for large lists as it has a linear time complexity. +- Better alternatives exist for sorted lists or when multiple searches are required. + +## References + +- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/linear-search/) +- **HackerRank Problem:** [HackerRank](https://www.hackerrank.com/challenges/linear-search/problem) +- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/) \ No newline at end of file diff --git a/dsa-solutions/Searching-Algorithms/02-Binary-Search.md b/dsa-solutions/Searching-Algorithms/02-Binary-Search.md new file mode 100644 index 000000000..2bcd9dab0 --- /dev/null +++ b/dsa-solutions/Searching-Algorithms/02-Binary-Search.md @@ -0,0 +1,200 @@ +--- +id: Binary-Search +title: Binary Search (Geeks for Geeks) +sidebar_label: Binary Search +tags: + - Beginner + - Search Algorithms + - Geeks for Geeks + - CPP + - Python + - Java + - JavaScript + - DSA +description: "This is a solution to the Binary Search problem on Geeks for Geeks." +--- + +## What is Binary Search? + +Binary Search is a highly efficient search algorithm used to find the position of a target element within a sorted list. It works by repeatedly dividing the search interval in half and comparing the target value to the middle element of the interval. + +## Algorithm for Binary Search + +1. Start with the left pointer at the beginning of the list and the right pointer at the end. +2. Calculate the middle index of the current search interval. +3. Compare the target value with the middle element: + - If the target value equals the middle element, return the middle index. + - If the target value is less than the middle element, move the right pointer to $middle - 1$. + - If the target value is greater than the middle element, move the left pointer to $middle + 1$. +4. Repeat steps 2-3 until the left pointer exceeds the right pointer. +5. If the target value is not found, return -1. + +## How does Binary Search work? + +- It starts by comparing the target value to the middle element of the list. +- If the target value matches the middle element, the search is complete. +- If the target value is less than the middle element, the search continues in the left half of the list. +- If the target value is greater than the middle element, the search continues in the right half of the list. +- This process continues until the target value is found or the search interval is empty. + +![Example for Binary Search(GFG)](../../assets/binnary-search-.webp) + +## Problem Description + +Given a sorted list and a target element, implement the Binary Search algorithm to find the index of the target element in the list. If the element is not present, return -1. + +## Examples + +**Example 1:** +``` +Input: +list = [1, 3, 5, 7, 9] +target = 5 +Output: 2 +``` + +**Example 2:** +``` +Input: +list = [2, 4, 6, 8, 10] +target = 7 +Output: -1 +``` + +## Your Task: + +You dont need to read input or print anything. Complete the function binarysearch() which takes arr[], N and K as input parameters and returns the index of K in the array. If K is not present in the array, return -1. + + +Expected Time Complexity: $O(LogN)$ +Expected Auxiliary Space: $O(LogN)$ if solving recursively and O(1) otherwise. + +## Constraints + +- $1 <= N <= 10^5$ +- $1 <= arr[i] <= 10^6$ +- $1 <= K <= 10^6$ + +## Implementation + + + + + ```python + def binary_search(lst, target): + left, right = 0, len(lst) - 1 + while left <= right: + mid = left + (right - left) // 2 + if lst[mid] == target: + return mid + elif lst[mid] < target: + left = mid + 1 + else: + right = mid - 1 + return -1 + ``` + + + + + ```cpp + #include + #include + + int binary_search(const std::vector& lst, int target) { + int left = 0, right = lst.size() - 1; + while (left <= right) { + int mid = left + (right - left) / 2; + if (lst[mid] == target) { + return mid; + } else if (lst[mid] < target) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return -1; + } + + int main() { + std::vector lst = {1, 3, 5, 7, 9}; + int target = 5; + std::cout << "Index: " << binary_search(lst, target) << std::endl; + return 0; + } + ``` + + + + + ```java + public class BinarySearch { + public static int binarySearch(int[] lst, int target) { + int left = 0, right = lst.length - 1; + while (left <= right) { + int mid = left + (right - left) / 2; + if (lst[mid] == target) { + return mid; + } else if (lst[mid] < target) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return -1; + } + + public static void main(String[] args) { + int[] lst = {1, 3, 5, 7, 9}; + int target = 5; + System.out.println("Index: " + binarySearch(lst, target)); + } + } + ``` + + + + + ```javascript + function binarySearch(lst, target) { + let left = 0, right = lst.length - 1; + while (left <= right) { + const mid = left + Math.floor((right - left) / 2); + if (lst[mid] === target) { + return mid; + } else if (lst[mid] < target) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return -1; + } + + const lst = [1, 3, 5, 7, 9]; + const target = 5; + console.log("Index:", binarySearch(lst, target)); + ``` + + + +## Complexity Analysis + +- **Time Complexity**: $O(log n)$, where $n$ is the number of elements in the list. The list is divided in half at each step, leading to logarithmic time complexity. +- **Space Complexity**: $O(1)$, as no extra space is required apart from the input list. + +## Advantages and Disadvantages + +**Advantages:** +- Highly efficient for large sorted lists. +- Fast search time due to logarithmic time complexity. + +**Disadvantages:** +- Requires the list to be sorted. +- Less efficient for small lists compared to linear search. + +## References + +- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/binary-search/) +- **HackerRank Problem:** [HackerRank](https://www.hackerrank.com/challenges/binary-search/problem) +- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/) \ No newline at end of file diff --git a/dsa-solutions/Searching-Algorithms/03-Breadth-First-Search (BFS).md b/dsa-solutions/Searching-Algorithms/03-Breadth-First-Search (BFS).md new file mode 100644 index 000000000..644b2f10e --- /dev/null +++ b/dsa-solutions/Searching-Algorithms/03-Breadth-First-Search (BFS).md @@ -0,0 +1,249 @@ +--- +id: Breadth-First-Search-BFS +title: Breadth First Search (BFS) (Geeks for Geeks) +sidebar_label: Breadth First Search (BFS) +tags: + - Beginner + - Graph Algorithms + - Geeks for Geeks + - CPP + - Python + - Java + - JavaScript + - DSA +description: "This is a solution to the Breadth First Search (BFS) problem on Geeks for Geeks." +--- + +## 1. What is Breadth First Search (BFS)? + +Breadth First Search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree's root (or an arbitrary node in the graph) and explores the neighbor nodes at the present depth prior to moving on to nodes at the next depth level. + +## 2. Algorithm for Breadth First Search (BFS) + +1. Initialize a queue and enqueue the starting node. +2. Mark the starting node as visited. +3. While the queue is not empty: + - Dequeue a node from the queue. + - Process the dequeued node (e.g., print its value). + - Enqueue all unvisited adjacent nodes of the dequeued node. + - Mark the newly enqueued nodes as visited. + +## 3. How does Breadth First Search (BFS) work? + +- BFS explores all nodes at the present depth level before moving on to nodes at the next depth level. +- It uses a queue data structure to keep track of nodes to be explored. +- Nodes are marked as visited to prevent reprocessing. + +## 4. Problem Description + +Given a graph represented as an adjacency list, implement the Breadth First Search (BFS) algorithm to traverse the graph starting from a given source node. + +## 5. Examples + +**Example 1:** +``` +Input: +graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] +} +start_node = 2 +Output: 2 0 3 1 +``` + +**Example 2:** +``` +Input: +graph = { + 0: [1, 3], + 1: [0, 2], + 2: [1, 3], + 3: [0, 2] +} +start_node = 0 +Output: 0 1 3 2 +``` + +## 6. Constraints + +- $The graph can have any number of nodes.$ +- $The graph can be directed or undirected.$ + +## 7. Implementation + + + + + ```python + from collections import deque + + def bfs(graph, start_node): + visited = set() + queue = deque([start_node]) + result = [] + + while queue: + node = queue.popleft() + if node not in visited: + visited.add(node) + result.append(node) + queue.extend(neighbor for neighbor in graph[node] if neighbor not in visited) + return result + + # Example usage: + graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] + } + start_node = 2 + print(bfs(graph, start_node)) + ``` + + + + + ```cpp + #include + #include + #include + #include + + std::vector bfs(const std::vector>& graph, int start_node) { + std::vector result; + std::queue queue; + std::unordered_set visited; + + queue.push(start_node); + visited.insert(start_node); + + while (!queue.empty()) { + int node = queue.front(); + queue.pop(); + result.push_back(node); + + for (int neighbor : graph[node]) { + if (visited.find(neighbor) == visited.end()) { + queue.push(neighbor); + visited.insert(neighbor); + } + } + } + return result; + } + + int main() { + std::vector> graph = { + {1, 2}, + {2}, + {0, 3}, + {3} + }; + int start_node = 2; + std::vector traversal = bfs(graph, start_node); + + for (int node : traversal) { + std::cout << node << " "; + } + return 0; + } + ``` + + + + + ```java + import java.util.*; + + public class BFS { + public static List bfs(Map> graph, int startNode) { + List result = new ArrayList<>(); + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + + queue.add(startNode); + visited.add(startNode); + + while (!queue.isEmpty()) { + int node = queue.poll(); + result.add(node); + + for (int neighbor : graph.get(node)) { + if (!visited.contains(neighbor)) { + queue.add(neighbor); + visited.add(neighbor); + } + } + } + return result; + } + + public static void main(String[] args) { + Map> graph = new HashMap<>(); + graph.put(0, Arrays.asList(1, 2)); + graph.put(1, Arrays.asList(2)); + graph.put(2, Arrays.asList(0, 3)); + graph.put(3, Arrays.asList(3)); + + int startNode = 2; + List traversal = bfs(graph, startNode); + System.out.println(traversal); + } + } + ``` + + + + + ```javascript + function bfs(graph, startNode) { + const visited = new Set(); + const queue = [startNode]; + const result = []; + + while (queue.length > 0) { + const node = queue.shift(); + if (!visited.has(node)) { + visited.add(node); + result.push(node); + queue.push(...graph[node].filter(neighbor => !visited.has(neighbor))); + } + } + return result; + } + + const graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] + }; + const startNode = 2; + console.log(bfs(graph, startNode)); + ``` + + + +## 8. Complexity Analysis + +- **Time Complexity**: $O(V + E)$, where $V$ is the number of vertices and $E$ is the number of edges. Each vertex and edge is processed once. +- **Space Complexity**: $O(V)$, where $V$ is the number of vertices. This is for the queue and the visited set. + +## 9. Advantages and Disadvantages + +**Advantages:** +- Finds the shortest path in unweighted graphs. +- Simple and easy to understand and implement. + +**Disadvantages:** +- Can be memory intensive as it stores all vertices in the queue. + +## 10. References + +- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/) +- **HackerRank Problem:** [HackerRank](https://www.hackerrank.com/challenges/breadth-first-search/problem) +- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/) + diff --git a/dsa-solutions/Searching-Algorithms/04-Depth-First-Search (DFS).md b/dsa-solutions/Searching-Algorithms/04-Depth-First-Search (DFS).md new file mode 100644 index 000000000..1a42a7e96 --- /dev/null +++ b/dsa-solutions/Searching-Algorithms/04-Depth-First-Search (DFS).md @@ -0,0 +1,220 @@ +--- +id: Depth-First-Search-DFS +title: Depth First Search (DFS) (Geeks for Geeks) +sidebar_label: Depth First Search (DFS) +tags: + - Beginner + - Graph Algorithms + - Geeks for Geeks + - CPP + - Python + - Java + - JavaScript + - DSA +description: "This is a solution to the Depth First Search (DFS) problem on Geeks for Geeks." +--- + +## 1. What is Depth First Search (DFS)? + +Depth First Search (DFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the root (or an arbitrary node in the graph) and explores as far as possible along each branch before backtracking. + +## 2. Algorithm for Depth First Search (DFS) + +1. Start with the root node (or an arbitrary node in the graph). +2. Mark the node as visited. +3. For each adjacent node, recursively apply the DFS algorithm if the node has not been visited. + +## 3. How does Depth First Search (DFS) work? + +- DFS explores as far as possible along each branch before backtracking. +- It uses a stack data structure, either implicitly through recursion or explicitly through an iterative approach. +- Nodes are marked as visited to prevent reprocessing. + +## 4. Problem Description + +Given a graph represented as an adjacency list, implement the Depth First Search (DFS) algorithm to traverse the graph starting from a given source node. + +## 5. Examples + +**Example 1:** +``` +Input: +graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] +} +start_node = 2 +Output: 2 0 1 3 +``` + +**Example 2:** +``` +Input: +graph = { + 0: [1, 3], + 1: [0, 2], + 2: [1, 3], + 3: [0, 2] +} +start_node = 0 +Output: 0 1 2 3 +``` + +## 6. Constraints + +- $The graph can have any number of nodes.$ +- $The graph can be directed or undirected.$ + +## 7. Implementation + + + + + ```python + def dfs(graph, start_node, visited=None): + if visited is None: + visited = set() + visited.add(start_node) + result = [start_node] + for neighbor in graph[start_node]: + if neighbor not in visited: + result.extend(dfs(graph, neighbor, visited)) + return result + + # Example usage: + graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] + } + start_node = 2 + print(dfs(graph, start_node)) + ``` + + + + + ```cpp + #include + #include + #include + + void dfsUtil(int node, const std::vector>& graph, std::unordered_set& visited, std::vector& result) { + visited.insert(node); + result.push_back(node); + for (int neighbor : graph[node]) { + if (visited.find(neighbor) == visited.end()) { + dfsUtil(neighbor, graph, visited, result); + } + } + } + + std::vector dfs(const std::vector>& graph, int start_node) { + std::unordered_set visited; + std::vector result; + dfsUtil(start_node, graph, visited, result); + return result; + } + + int main() { + std::vector> graph = { + {1, 2}, + {2}, + {0, 3}, + {3} + }; + int start_node = 2; + std::vector traversal = dfs(graph, start_node); + + for (int node : traversal) { + std::cout << node << " "; + } + return 0; + } + ``` + + + + + ```java + import java.util.*; + + public class DFS { + public static List dfs(Map> graph, int startNode, Set visited) { + List result = new ArrayList<>(); + visited.add(startNode); + result.add(startNode); + + for (int neighbor : graph.get(startNode)) { + if (!visited.contains(neighbor)) { + result.addAll(dfs(graph, neighbor, visited)); + } + } + return result; + } + + public static void main(String[] args) { + Map> graph = new HashMap<>(); + graph.put(0, Arrays.asList(1, 2)); + graph.put(1, Arrays.asList(2)); + graph.put(2, Arrays.asList(0, 3)); + graph.put(3, Arrays.asList(3)); + + int startNode = 2; + Set visited = new HashSet<>(); + List traversal = dfs(graph, startNode, visited); + System.out.println(traversal); + } + } + ``` + + + + + ```javascript + function dfs(graph, startNode, visited = new Set()) { + visited.add(startNode); + const result = [startNode]; + for (const neighbor of graph[startNode]) { + if (!visited.has(neighbor)) { + result.push(...dfs(graph, neighbor, visited)); + } + } + return result; + } + + const graph = { + 0: [1, 2], + 1: [2], + 2: [0, 3], + 3: [3] + }; + const startNode = 2; + console.log(dfs(graph, startNode)); + ``` + + + +## 8. Complexity Analysis + +- **Time Complexity**: $O(V + E)$, where $V$ is the number of vertices and $E$ is the number of edges. Each vertex and edge is processed once. +- **Space Complexity**: $O(V)$, where $V$ is the number of vertices. This is for the visited set and the recursive stack space. + +## 9. Advantages and Disadvantages + +**Advantages:** +- Can be easily implemented with recursion. +- Useful for problems that involve exploring all paths, like puzzles and mazes. + +**Disadvantages:** +- Can be memory intensive due to the stack space in recursion. +- Not optimal for finding the shortest path in unweighted graphs. + +## 10. References + +- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/) +- **HackerRank Problem:** [HackerRank](https://www.hackerrank.com/challenges/depth-first-search/problem) +- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/)