update on sorting algorithms

Heap Sort and other sorts missing

Author: Blooverh

DataAndAlgoL/Chpt10SortingAlgorithms/Chpt10Notes.org

@@ -49,4 +49,42 @@
             - 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 
 
-    ** SHELL SORT (DIMINISHING INCREMENT SORT)
+    ** SHELL SORT (DIMINISHING INCREMENT SORT)
+        >> generalization of insertion sort.
+        *** NOTE -> Insertion sort works efficiently on input that is already almost sorted
+        >> SHELL SORT AKA *N-gap* insertion sort. 
+        ** Instead of comparing only the adjacent pair, shell sort makes several passes and uses various gaps between adjacent elements, ending with the gap of 1 or classical insertion sort 
+        ** Variation used in shell sort is to avoid comparing adjacent elements until the last step of the algorithm, meaning last step of the shell sort is insertion sort algorithm
+        ** Fastes of all O(N^2) algorithms  
+
+    ** MERGE SORT
+        >> Important example of divide and conquer 
+        *** IMPORTANT NOTES:
+            *merging* -> process of combining 2 sorted files to make one bigger sorted file 
+            *selection* -> process of dividing a file into 2 parts: k smallest element and n - k largest elements 
+            *Selection and Merging* -> 2 opposite operations:
+                selection splits the list into 2 lists 
+                merging joins 2 list to make 1 list 
+            *Merge Sort -> is Quick Sort's complement* and accesses the data in sequential order 
+            ** NOTE -> this algorithm is used for sorting a LINKED LIST 
+            ** Insensitive to the initial order of its input 
+            *** NOTE -> Merge sort divides the list into 2 parts, each part is conquered individually.
+            *** Merge sort starts with the small sublists and finishes with the largest list. As a result does not need a stack
+            ** Stable alfgorithm
+
+    ** QUICK SORT 
+        ** Example of divide and conquer algorithm. AKA Paritition Exchange Sort -> Uses recursive calls for sorting elements
+        *** NOTE: One of the famous algorithms among comparison-based sorting algorithms 
+        ** STEPS: 
+            ** DIVIDE: Array[low...high]is partitioned into 2 non-empty subarrays Array[low... pivot] and Array[pivot+1... high] 
+                ** Such that each element of Array[low... high] is less than or equal to each element of Array[pivot+1... high]
+                ** PIVOT index is calculated as part of the partitioning procedure   
+            ** CONQUER:
+                ** The 2 subarrays Array[low... pivot] and Array[pivot+1... high] are sorted by recursive calls 
+        ** ALGORITHM:
+            *** 1. If there are 1 or no elements in the array to be sorted return.
+            *** 2. Pick and element in the array to serve as the PIVOT point. (USUALLY THE LEFT MOST ELEMENT IN THE ARRAY IS USED)
+            *** 3. Split the array into 2 parts- 1 with elements larger than the pivot, other with elements smaller than the PIVOT
+            *** 4. Recursively repeat the algorithm for both halves of the original array 
+            
+    ** HEAP SORT

DataAndAlgoL/Chpt10SortingAlgorithms/MergeSort.java

@@ -0,0 +1,56 @@
+package DataAndAlgoL.Chpt10SortingAlgorithms;
+
+import java.util.Arrays;
+
+public class MergeSort {
+    public static void main(String[] args) {
+        int[] list ={2,3,2,6,5,1,-2,3,14,12};
+        mergeSort(list);
+        System.out.println(Arrays.toString(list));
+    }
+
+    public static void mergeSort(int[] list){
+        if(list.length > 1){
+            //merge sort 1st half
+            int[] firstHalf= new int[list.length/2];
+            System.arraycopy(list, 0, firstHalf, 0, list.length/2);
+            mergeSort(firstHalf); //recursive call to merge the first half of the current recursive list
+
+            //merge sort 2nd Half
+            int secondHalfLength= list.length - list.length/2;
+            int[] secondHalf= new int[secondHalfLength];
+            System.arraycopy(list, list.length/2, secondHalf, 0, secondHalfLength);
+            mergeSort(secondHalf); //recursive call to merge the second half of the list of the current recursive list 
+
+            //merge first half with second half int list (original list) 
+            merge(firstHalf, secondHalf, list);
+            
+        }
+    }
+
+    public static void merge(int[] list1, int[] list2, int[] temp){
+        int current1=0; //current index in list 1
+        int current2=0; //current index in list 2
+        int current3=0;  //current index in list temp
+        
+        //while both lists have the same size 
+        while(current1 < list1.length && current2 < list2.length){
+            if(list1[current1] < list2[current2]){
+                temp[current3++]=list1[current1++];
+            }else{
+                temp[current3++]= list2[current2++];
+            }
+        }
+
+        //if list 1 has larger size than list 2 append the rest 
+        while(current1 < list1.length){
+            temp[current3++] = list1[current1++];
+        }
+
+        //if list 2 has a larger size than list 1, append the rest
+        while(current2 < list2.length){
+            temp[current3++]=list2[current2++];
+        }
+        
+    }
+}

DataAndAlgoL/Chpt10SortingAlgorithms/QuickSort.java

@@ -0,0 +1,52 @@
+package DataAndAlgoL.Chpt10SortingAlgorithms;
+
+public class QuickSort {
+    public static void main(String[] args) {
+        
+    }
+
+    public static void quickSort(int[] nums, int low, int high){
+        int pivot;
+        //termination condition -> where it runs until it reaches stopping point
+        if(high > low){
+            pivot= Partition(nums, low, high);
+            quickSort(nums, low, pivot-1); 
+            quickSort(nums, pivot+1, high);
+        }
+    }
+
+    public static int Partition(int[] nums, int low, int high){
+        int left=low;
+        int right=high;
+        int pivot_item= nums[low];
+
+        while(left < right){
+            //Move left while item < pivot
+            while(nums[left]<= pivot_item){
+                left++;
+            } 
+
+            //Move right while item > pivot
+            while(nums[right] >= pivot_item){
+                right--;
+            }
+            //when index left is higher than index high we swap the elements in left index with right index
+            if(left < right){
+                swap(nums, left, right);
+            }
+
+        }
+        
+        //right is final position for the pivot
+        nums[low]= nums[high];
+        nums[right]= pivot_item;
+        return right;
+    }
+
+    public static void swap(int[] nums, int left, int right){
+     int temp=0;
+     temp= nums[left];
+     nums[left]= nums[right];
+     nums[right]=temp;       
+    }
+}

DataAndAlgoL/Chpt10SortingAlgorithms/ShellSort.java

@@ -0,0 +1,29 @@
+package DataAndAlgoL.Chpt10SortingAlgorithms;
+
+public class ShellSort {
+    public static void main(String[] args) {
+        
+    }
+
+    public static void shellSort(int[] nums){
+        int i;
+        int j;
+        int v;
+        int h;
+
+        for(h=1; h <-nums.length/9; h=3*h+1);
+        for(; h>0; h=h/3){
+            for(i= h+1; i<= nums.length; i++){
+                v= nums[i];
+                j=i;
+                while(j > h && nums[j-h]> v){
+                    nums[j]= nums[j-h];
+                    j-=h;
+                }
+
+                nums[j]=v;
+            }
+        }
+        
+    }
+}