Merge pull request #26 from 2G-Afroz/2G-Afroz-Patch-2

Added pseudocode for Selection Sort and Insertion Sort Algorithm.

Author: 2G-Afroz

Algorithms/Sort/InsertionSort/README.md

@@ -0,0 +1,40 @@
+# Insertion Sort
+Insertion sort is a simple sorting algorithm that builds the final sorted array one element at a time. It is much less efficient on large lists than more advanced algorithms such as `QuickSort`, `MergeSort`, or `HeapSort`. However, it performs well for small datasets or lists that are nearly sorted.
+
+## Pseudocode
+```plaintext
+function insertionSort(array):
+    n = array.length()
+    for i = 1 to n - 1:
+        key = array[i]
+        j = i - 1
+
+        # Move elements greater than key to one position ahead
+    	while j >= 0 and array[j] > key:
+        	array[j + 1] = array[j]
+        	j = j - 1
+
+    	# Place the key at its correct position
+    	array[j + 1] = key
+```
+
+## Time & Space Complexity
+|Case    |Time            |Space |
+|--------|---------------:|-----:|
+|Best    |Ω(n)            |Ω(1)  |
+|Average |Θ(n<sup>2</sup>)|Θ(1)  |
+|Worst   |O(n<sup>2</sup>)|O(1)  |
+
+## Variants
+- Binary Insertion Sort
+- Shell Sort
+
+## Use Cases
+- Effective for small datasets or nearly sorted lists.
+- Well-suited for situations where the input array is already partially sorted.
+- Simplicity and low overhead make it suitable for educational purposes.
+
+## Best Practices
+- Inefficient for large datasets, opt for more efficient algorithms like `QuickSort` or `MergeSort`.
+- Consider using variants like Binary Insertion Sort for slightly better performance.
+- Well-suited for scenarios where elements are added to the array sequentially over time.

Algorithms/Sort/SelectionSort/README.md

@@ -0,0 +1,43 @@
+# Selection Sort
+Selection sort is a straightforward sorting algorithm that sorts an array by repeatedly finding the minimum element from the unsorted part of the array and putting it at the beginning. The process is iteratively applied to the remaining unsorted elements until the entire array is sorted.
+
+## Pseudocode
+```plaintext
+function selectionSort(array):
+    n = array.length()
+    for i = 0 to n - 1:
+        # Assume the current index is the minimum
+        minIndex = i
+
+        # Search for the minimum element in the unsorted part
+        for j = i + 1 to n - 1:
+            if array[j] < array[minIndex]:
+                minIndex = j
+
+        # Swap the found minimum element with the first element
+        temp = array[minIndex]
+        array[minIndex] = array[i]
+        array[i] = temp
+```
+
+## Time & Space Complexity
+|Case    |Time            |Space |
+|--------|---------------:|-----:|
+|Best    |Ω(n<sup>2</sup>)|Ω(1)  |
+|Average |Θ(n<sup>2</sup>)|Θ(1)  |
+|Worst   |O(n<sup>2</sup>)|O(1)  |
+
+## Variants
+- Double-Selection Sort
+- Stable Selection Sort
+- Recursive Selection Sort
+- Block-Swap Selection Sort
+
+## Use Cases
+- Suitable for sorting small datasets due to its simplicity.
+- Applicable in situations with constrained memory where constant space complexity is advantageous.
+- Considered when the cost of swapping elements is significantly higher than the cost of comparisons.
+
+## Best Practices
+- Inefficient for large datasets, opt more efficient algorithms like `Merge Sort` or `QuickSort`.
+- Explore variants or optimizations, such as stable selection sort, based on specific requirements.