Summary: sorting Algorithms

Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort.

Time Complexity: O(N^2)

for i ← 1 to length(A) - 1
    j ← i
    while j > 0 and A[j-1] > A[j]
        swap A[j] and A[j-1]
        j ← j - 1

Bubble sort has worst-case and average complexity both О(n²)

First Pass:
( 5 1 4 2 8 )  ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.
( 1 5 4 2 8 )  ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 )  ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 )  ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.
Second Pass:
( 1 4 2 5 8 )  ( 1 4 2 5 8 )
( 1 4 2 5 8 )  ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.
Third Pass:
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )

procedure bubbleSort( A : list of sortable items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n-1 inclusive do
       /* if this pair is out of order */
       if A[i-1] > A[i] then
         /* swap them and remember something changed */
         swap( A[i-1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure

 selection sort is a sorting algorithm, specifically an in-place comparison sort. It has O(n²) time complexity, making it inefficient on large lists

Time Complexty: O(N^2)

public class MySelectionSort {
 
    public static int[] doSelectionSort(int[] arr){
         
        for (int i = 0; i < arr.length - 1; i++)
        {
            int index = i;
            for (int j = i + 1; j < arr.length; j++)
                if (arr[j] < arr[index])
                    index = j;
      
            int smallerNumber = arr[index]; 
            arr[index] = arr[i];
            arr[i] = smallerNumber;
        }
        return arr;
    }
     
    public static void main(String a[]){
         
        int[] arr1 = {10,34,2,56,7,67,88,42};
        int[] arr2 = doSelectionSort(arr1);
        for(int i:arr2){
            System.out.print(i);
            System.out.print(", ");
        }
    }
}

 or

/* a[0] to a[n-1] is the array to sort */
int i,j;
int iMin;
 
/* advance the position through the entire array */
/*   (could do j < n-1 because single element is also min element) */
for (j = 0; j < n-1; j++) {
    /* find the min element in the unsorted a[j .. n-1] */
 
    /* assume the min is the first element */
    iMin = j;
    /* test against elements after j to find the smallest */
    for ( i = j+1; i < n; i++) {
        /* if this element is less, then it is the new minimum */  
        if (a[i] < a[iMin]) {
            /* found new minimum; remember its index */
            iMin = i;
        }
    }
 
    if(iMin != j) {
        swap(a[j], a[iMin]);
    }
 
}

 Descending Order:

public class descending {
         
        public static int[] doSelectionSort(int[] arr){
             
            for (int i = arr.length-1; i >= 1; i--)
            {
                int index = i;
                for (int j = 0; j < i; j++)
                    if (arr[j] < arr[index])
                        index = j;
          
                int smallerNumber = arr[index]; 
                arr[index] = arr[i];
                arr[i] = smallerNumber;
            }
            return arr;
        }
         
        public static void main(String[] args){
             
            int[] arr1 = {10,34,2,56,7,67,88,42};
            int[] arr2 = doSelectionSort(arr1);
            for(int i:arr2){
                System.out.print(i);
                System.out.print(", ");
            }
        }
}

 Merge Sort:

package ArrayMergeSort;

import java.util.Arrays;

public class Solution {
    public int[] mergeSort(int[] arr) {
        if (arr.length == 1) return arr;
        else {
            int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length/2);
            int[] arr2 = Arrays.copyOfRange(arr, arr.length/2, arr.length);
            return merge(mergeSort(arr1), mergeSort(arr2));
        }
    }
    
    public int[] merge(int[] arr1, int[] arr2) {
        int len1 = arr1.length;
        int len2 = arr2.length;
        int[] res = new int[len1+len2];
        int i = 0, j=0, cur=0;
        while (i<len1 && j<len2) {
            if (arr1[i] <= arr2[j]) {
                res[cur++] = arr1[i++];
            }
            else {
                res[cur++] = arr2[j++];
            }
        }
        while (i<len1) {
            res[cur++] = arr1[i++];
        }
        while (j<len2) {
            res[cur++] = arr2[j++];
        }
        return res;
    }
    
    

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Solution sol = new Solution();
        int[] arr = sol.mergeSort(new int[]{6,5,4,8,2,1});
        System.out.println(Arrays.toString(arr));
    }

}