update

Author: Blooverh

DataAndAlgoL/Chpt10SortingAlgorithms/Chpt10Notes.org

@@ -19,4 +19,33 @@
         Bubble sort continues its iterations until no more swaps are needed.
         Has high complexity time and is too Simplest
         ** Only significant advantage of bubble sort is detecting whether input list is sorted or not 
-        
+        
+    ** SELECTION SORT
+        *** Works well for small files. Used to sort very large values with very small keys. Because selecyion is made based on keys and swaps are made only when required 
+            Advantages: 
+                Easy to implement 
+                in-place sort (requires no additional storage space)
+            Disadvantages:
+                does not scale well O(n^2)
+        *** Algorithm used as:
+            1. finding the minimum value in the list 
+            2. swap it with the value in the current position
+            3. repeat process for all elements until the entire array is sorted
+    
+    ** INSERTION SORT 
+        simple and efficient comparison sort. 
+        ** Each iteration removes an element from the input data and inserts it into the correct position in the list being sorted. 
+            ** The choice of the element being removed from the input is random and this process is repeated until all elements are sorted.
+        ** ADVANTAGES:
+            simple implementation 
+            efficient for small data
+            adaptive: if the input list is presorted [may not be completely] the insertions sort takes O(n+d), where d is the number of inversions.
+            Pratically more efficient than selection sort and bubble sort, even tho all of them have O(n^2) worst case complexity
+            stable: maintains relative order of input data if the keys are the same
+            in-place: it requires only a constant  amount O(1) of additional memory space 
+            Online: insertion sort can sort the list as it receives it
+        ** ALGORITHM:
+            - Every repetition of insertion removes an element from the input data, and inserts it into the correct position in the already sorted list until no input elements remain.
+            - Sorting is typically done in-place. The resulting array after k iterations has the property where the first k+1 entries are sorted 
+
+PAGE -> 514

DataAndAlgoL/Chpt10SortingAlgorithms/InsertionSort.java

@@ -0,0 +1,27 @@
+package DataAndAlgoL.Chpt10SortingAlgorithms;
+
+import java.util.Arrays;
+
+public class InsertionSort {
+    public static void main(String[] args) {
+        int[] nums={2,1,6,34,4,7,55,3};
+        insertionSort(nums);
+    }
+
+    public static void insertionSort(int[] arr){
+
+        for(int i=1; i<arr.length; i++){
+            int v=arr[i]; // holds value of key i
+            int j=i-1; // holds key i
+            // while previous key is > and v (current key) and j >=1, assign arr[j] with previous value arr[j-1]
+            while(arr[j] > v && j >= 0){
+                arr[j+1] = arr[j];
+                j--; // decrement j by 1 to previous position arr[j-1]
+            }
+
+            arr[j+1]=v;// stores the value from current position that was swapped with value of previous position
+        }
+
+        System.out.println(Arrays.toString(arr));
+    }
+}

DataAndAlgoL/Chpt10SortingAlgorithms/SelectionSort.java

@@ -0,0 +1,32 @@
+package DataAndAlgoL.Chpt10SortingAlgorithms;
+
+import java.util.Arrays;
+
+public class SelectionSort {
+    public static void main(String[] args) {
+        int[] nums={2,1,6,34,4,7,55,3};
+        selectionSort(nums);
+    
+    }
+
+    //O(n^2) runtime. 2 nested for loops goes through n^2 inputs 
+    public static void selectionSort(int[] nums){
+        int min; // Stores minimum value in list 
+        int temp; // holds values for swappage 
+
+        for(int i=0; i < nums.length-1; i++){
+            min=i;
+            for(int j= i+1; j< nums.length; j++){ //for each iteration, goes through all the array starting at i and compares j to current min 
+                if(nums[j] < nums[min]){
+                    min=j;
+                }
+            }
+            //Swap elements
+            temp= nums[min];
+            nums[min]= nums[i];
+            nums[i]=temp;
+        }
+
+       System.out.println(Arrays.toString(nums));
+    }
+}