Added all the changes

Author: Faisal786111

Hash/Chaining/Readme.md

@@ -0,0 +1,27 @@
+# Chaining in Hashing
+
+Chaining is a method used to resolve hash collisions in hash tables. In this method, each bucket (or slot) of the hash table stores a linked list of all elements that hash to the same index. When a collision occurs, the element is simply added to the linked list at that index.
+
+<p align="center">
+  <img src="https://media.geeksforgeeks.org/wp-content/cdn-uploads/gq/2015/07/hashChaining1.png" alt="Chaining in Hashing">
+</p>
+
+### Time and Space Complexity
+
+| **Operation**      | **Average Case** | **Worst Case** |
+|--------------------|------------------|----------------|
+| **Search**         | O(1)             | O(n)           |
+| **Insert**         | O(1)             | O(n)           |
+| **Delete**         | O(1)             | O(n)           |
+
+### Explanation
+
+- **Search**: On average, the search operation takes constant time since elements are stored in a linked list in each bucket. However, in the worst case, all elements could hash to the same bucket, resulting in a linear search.
+  
+- **Insert**: Insertion also takes constant time on average. If a collision occurs, the element is added to the linked list at the corresponding bucket.
+  
+- **Delete**: Deletion follows the same approach as the search operation: O(1) on average but could degrade to O(n) in the worst case.
+
+### Space Complexity
+
+The space complexity of chaining in hashing is O(n), where n is the number of elements in the hash table. This is because, in the worst case, all elements can be stored in a single linked list.

Hash/Linear Probing/Readme.md

@@ -0,0 +1,27 @@
+# Linear Probing in Hashing
+
+Linear Probing is a collision resolution technique used in open addressing to resolve hash collisions. When a collision occurs, linear probing checks the next available slot in a sequential manner (i.e., it moves linearly through the hash table until an empty slot is found).
+
+<p align="center">
+  <img src="https://media.geeksforgeeks.org/wp-content/uploads/Linear-Probing-1-1.jpg" alt="Linear Probing in Hashing">
+</p>
+
+### Time and Space Complexity
+
+| **Operation**      | **Average Case** | **Worst Case** |
+|--------------------|------------------|----------------|
+| **Search**         | O(1)             | O(n)           |
+| **Insert**         | O(1)             | O(n)           |
+| **Delete**         | O(1)             | O(n)           |
+
+### Explanation
+
+- **Search**: In linear probing, the search operation can be very efficient if the load factor is low. However, if many slots are occupied, it might take longer, resulting in O(n) time complexity in the worst case.
+  
+- **Insert**: Insertions are generally efficient with linear probing, but in cases where the hash table is nearing its capacity, insertions might degrade to O(n) as the algorithm will need to probe multiple slots to find an available one.
+  
+- **Delete**: Deletion works similarly to insertion. In cases of full tables or long chains of collisions, the time complexity may degrade to O(n).
+
+### Space Complexity
+
+The space complexity of linear probing is O(n), where n is the number of elements in the hash table. This is because the space is determined by the size of the hash table itself, and additional space is not required beyond the table.

README.md

@@ -40,13 +40,17 @@ This repository contains implementations of various data structures and algorith
   - Min Heap
   - Max Heap
   - Heap Operations (Insert, Delete, Heapify)
-- [Hashing](./Hash/Chaining)
-  - Hashing with Chaining
+- [Hashing](./Hash)
+  - [Hashing with Chaining](./Hash/Chaining)
+  - [Hashing with Linear Probing](./Hash/Linear%20Probing)
+  - [Hashing with Quadratic Probing](./Hash/Quadratic%20Probing)
+  - [Hashing with Double Hashing](./Hash/Double%20Hashing)
 
 ## Algorithms
 
 - [Sorting Algorithms](./sorting%20algo)
 - [Recursion](./recursion)
+- [Searching Algorithms](./search%20algo)
 
 ## Notes
 

Search/BinarySearch/readme.md

@@ -0,0 +1,13 @@
+# Binary Search
+
+Binary Search is a more efficient algorithm for finding an element in a sorted list by repeatedly dividing the search interval in half. If the value of the search key is less than the item in the middle of the interval, the search continues in the left half. Otherwise, it continues in the right half.
+
+<p align="center">
+  <img src="https://media.geeksforgeeks.org/wp-content/uploads/20240506155201/binnary-search-.webp" alt="Binary Search">
+</p>
+
+### Time and Space Complexity
+
+| **Algorithm**     | **Time Complexity** | **Space Complexity** |
+|-------------------|---------------------|----------------------|
+| **Binary Search**  | O(log n)            | O(1)                 |

Search/LinearSearch/Readme.md

@@ -0,0 +1,13 @@
+# Linear Search
+
+Linear Search is a simple search algorithm that checks each element of a list sequentially until it finds the target or reaches the end of the list.
+
+<p align="center">
+  <img src="https://media.geeksforgeeks.org/wp-content/uploads/20240506105158/Linear-Search-algorithm-banner-(1).webp" alt="Linear Search">
+</p>
+
+### Time and Space Complexity
+
+| **Algorithm**      | **Time Complexity** | **Space Complexity** |
+|--------------------|---------------------|----------------------|
+| **Linear Search**   | O(n)                | O(1)                 |

Search/Readme.md

@@ -0,0 +1,25 @@
+# Searching Algorithms
+
+Searching algorithms are designed to check whether a specific element exists within a data structure or to retrieve its position if it exists.
+
+<p align="center">
+  <img src="https://media.geeksforgeeks.org/wp-content/cdn-uploads/20230726172447/Searching-algorithm.png" alt="Searching Algorithms">
+</p>
+
+## Linear Search
+Linear Search is a simple algorithm that checks every element in the list sequentially until it finds the target or reaches the end.
+
+### Time and Space Complexity
+
+| **Algorithm**      | **Time Complexity** | **Space Complexity** |
+|--------------------|---------------------|----------------------|
+| **Linear Search**   | O(n)                | O(1)                 |
+
+## Binary Search
+Binary Search is a more efficient algorithm than Linear Search. It works on sorted arrays and repeatedly divides the search interval in half.
+
+### Time and Space Complexity
+
+| **Algorithm**      | **Time Complexity** | **Space Complexity** |
+|--------------------|---------------------|----------------------|
+| **Binary Search**   | O(log n)            | O(1)                 |

sorting algo/Insertion/Readme.md

@@ -0,0 +1,74 @@
+# Insertion Sort
+
+![Insertion Sort Banner](https://media.geeksforgeeks.org/wp-content/uploads/20240408140301/Insertion-Sort.webp)
+
+This repository contains the implementation of **Insertion Sort**, a simple and intuitive sorting algorithm that builds the final sorted array one element at a time. It is particularly efficient for small datasets or partially sorted data.
+
+---
+
+## Table of Contents
+1. [Introduction](#introduction)
+2. [Algorithm Steps](#algorithm-steps)
+3. [Time and Space Complexity](#time-and-space-complexity)
+4. [Advantages and Disadvantages](#advantages-and-disadvantages)
+5. [Usage](#usage)
+6. [Contact](#contact)
+
+---
+
+## Introduction
+
+Insertion Sort is a comparison-based sorting algorithm that works by dividing the input into a sorted and an unsorted part. Elements from the unsorted part are picked one at a time and inserted into their correct position in the sorted part.  
+
+---
+
+## Algorithm Steps
+
+1. Start with the second element (index 1), assuming the first element is already sorted.
+2. Compare the current element with the elements in the sorted part of the array.
+3. Shift all larger elements in the sorted part to the right to make room for the current element.
+4. Insert the current element into its correct position.
+5. Repeat until all elements are sorted.
+
+**Example:**  
+For an array `[5, 3, 4, 1, 2]`, the algorithm works as follows:  
+- Pass 1: `[3, 5, 4, 1, 2]`  
+- Pass 2: `[3, 4, 5, 1, 2]`  
+- Pass 3: `[1, 3, 4, 5, 2]`  
+- Pass 4: `[1, 2, 3, 4, 5]`
+
+---
+
+## Time and Space Complexity
+
+| Case          | Time Complexity | Explanation                                          |
+|---------------|-----------------|------------------------------------------------------|
+| **Best Case** | O(n)            | Array is already sorted; only one comparison per element. |
+| **Average Case** | O(n²)         | Each element is compared with all previous elements in the worst case. |
+| **Worst Case** | O(n²)          | Array is sorted in reverse order; maximum comparisons are needed. |
+| **Space Complexity** | O(1)      | In-place sorting algorithm, no additional space is required. |
+
+---
+
+## Advantages and Disadvantages
+
+### Advantages:
+- Simple and easy to implement.
+- Efficient for small datasets or nearly sorted data.
+- Stable sorting algorithm (preserves the order of equal elements).
+
+### Disadvantages:
+- Inefficient for large datasets due to O(n²) time complexity.
+
+---
+
+## Usage
+
+To compile and run the code for **Insertion Sort**, use the following commands:
+
+```bash
+# Compile the code
+gcc insertion_sort.c -o insertion_sort
+
+# Run the executable
+./insertion_sort

sorting algo/InsertionSort.c

@@ -0,0 +1,25 @@
+# Merge Sort
+
+Merge Sort is a divide-and-conquer algorithm that splits an array into halves, recursively sorts each half, and then merges the sorted halves back together.
+
+<p align="center">
+  <img src="https://startutorial.com/img/merge-sort-split.jpg" alt="Merge Sort Illustration" width="500" height="500">
+</p>
+
+## How Merge Sort Works
+1. **Divide**: Split the array into two halves.
+2. **Conquer**: Recursively sort each half.
+3. **Merge**: Combine the sorted halves into a single sorted array.
+
+## Example
+Consider an array `[38, 27, 43, 3, 9, 82, 10]`. Using merge sort:
+1. Split into `[38, 27, 43, 3]` and `[9, 82, 10]`.
+2. Continue splitting until single-element arrays are obtained.
+3. Merge back step by step until the array is fully sorted: `[3, 9, 10, 27, 38, 43, 82]`.
+
+## Time and Space Complexity
+
+| **Complexity** | **Best Case** | **Average Case** | **Worst Case** |
+|----------------|---------------|------------------|----------------|
+| **Time**       | O(n log n)    | O(n log n)       | O(n log n)     |
+| **Space**      | O(n)          | O(n)             | O(n)           |

sorting algo/Merge/Readme.md

@@ -0,0 +1,25 @@
+# Quick Sort
+
+Quick Sort is a divide-and-conquer algorithm. It picks an element as a pivot and partitions the given array around the pivot. The array is then recursively sorted on either side of the pivot.
+
+<p align="center">
+  <img src="https://www.geeksforgeeks.org/wp-content/uploads/gq/2014/01/QuickSort2.png" alt="Quick Sort Illustration">
+</p>
+
+## How Quick Sort Works
+1. **Choose a pivot**: Select an element from the array (commonly the last element) as the pivot.
+2. **Partition**: Rearrange the array so that elements smaller than the pivot are on the left, and elements larger are on the right.
+3. **Recursively sort**: Recursively apply the same process to the left and right subarrays.
+
+## Example
+Consider the array `[10, 80, 30, 90, 40, 50, 70]` and choosing 70 as the pivot:
+1. Partition the array around 70: `[10, 30, 40, 50, 70, 90, 80]`.
+2. Recursively sort the left and right subarrays: `[10, 30, 40, 50]` and `[80, 90]`.
+3. Final sorted array: `[10, 30, 40, 50, 70, 80, 90]`.
+
+## Time and Space Complexity
+
+| **Complexity** | **Best Case** | **Average Case** | **Worst Case** |
+|----------------|---------------|------------------|----------------|
+| **Time**       | O(n log n)    | O(n log n)       | O(n²)          |
+| **Space**      | O(log n)      | O(log n)         | O(n)           |