sorting simplified

Readme

Press the "Regen array" button to randomize the array.
- This button can also be pressed during the execution of an algorithm, this way part of the newly randomized array will be sorted along with the algorithm.
Press the different sort buttons to sort the array.
- Different sort buttons can be pressed one after another to visualize 2 or more algorithms working together at the same time.
The text box takes inputs in terms of milliseconds(ms),this will determine time taken in each step during the sorting process.
- Dont forget to press the update button, values wont update if it is not pressed.
- Update can be done when an algorithm is running, to speed up or slow down the process in real time.
- Give higher values (around 100ms) for better visualization while running two or more algorithms together.
Colors used in visualization.
- Bubble sort : Scanning and Selected element : Green
- Insertion sort : Scanning and Selected element : Red
- Selection sort : Scanning and Selected element : Cyan | Element which changes place : Brown
- Shell sort : Scanning and Selected element : Pink | Gap : Grey
- Cocktail shaker sort : Selected element : Purple
- Counting sort : Scanning : Yellow
- Radix sort : Scanning : Blue
- Merge sort : Left Array : Orange : Right Array : Lightgreen
- Quick sort : Pivot : Red : Scanning : Yellow

Bubble sort

Loop through the array, and keep checking two consecutive.
Swap the elements with each other if needed(to arrange in a ascending or descending order).
After looping once the last element of the array will be set as highest or lowest.
loop again but only size-1 times, continue till array is sorted.

                    bubbleSort(array[])
                    {
                        int size = array.length;
                        for (int i = 0; i < size - 1; i++)
                          for (int j = 0; j < size - i - 1; j++)
                    
                            if (array[j] > array[j + 1]) {
                              int temp = array[j];
                              array[j] = array[j + 1];
                              array[j + 1] = temp;
                            }
                    }

Insertion sort

First check 2 elements and swap the lowest to the front.
Now check 3 elements and put the 3rd element in the proper possition by swapping.
Now check 4 elements and put the 4th element in the proper possition by swapping.
Continue this till the whole array is sorted.
Every time the front portion of the array is sorted.

                        sort(int arr[]) 
                        { 
                            int n = arr.length; 
                            for (int i = 1; i < n; ++i) { 
                                int key = arr[i]; 
                                int j = i - 1; 
                    
                                while (j >= 0 && arr[j] > key) { 
                                    arr[j + 1] = arr[j]; 
                                    j = j - 1; 
                                } 
                                arr[j + 1] = key; 
                            } 
                        }

Selection sort

Scan whole array put smallest in first position.
Scan the whole array (except) first and put smallest in second position.
This way move the sorted array boundary and find minimum from unsorted.

                    sort(int arr[]) 
                    { 
                        int n = arr.length; 
                  
                        for (int i = 0; i < n-1; i++) 
                        { 
                            int min_idx = i; 
                            for (int j = i+1; j < n; j++) 
                                if (arr[j] < arr[min_idx]) 
                                    min_idx = j; 
                  
                            int temp = arr[min_idx]; 
                            arr[min_idx] = arr[i]; 
                            arr[i] = temp; 
                        } 
                    }

Shell sort

Pick a gap of size/2.
Move this gap form the start to end and every time compare the first and last element of the gap , and swap if needed.
Do gap/2 and repeat, till gap = 0.

                    sort(int arr[]) 
                    { 
                        int n = arr.length; 
                        for (int gap = n/2; gap > 0; gap /= 2) 
                        {  
                            for (int i = gap; i < n; i += 1) 
                            {  
                                int temp = arr[i];  
                                int j; 
                                for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) 
                                    arr[j] = arr[j - gap];  
                                arr[j] = temp; 
                            } 
                        } 
                        return 0; 
                    }

Cocktail sort

This is like bubble sort.
After reaching the end and placing the largest value , start iterating from there to the start and on the way swap elements to place the smallest at start.
Iteration ends at the middle.

                    cocktail_sort(){
                        int start = 0;
                        int end = l-1;
                        unt i = 0;
                        while(start <= end)
                        {
                            if(i%2==0)
                            {
                                for(int j = start;j<end;j++)
                                {
                                    if(arr[j]>arr[j+1])
                                    {
                                        temp = arr[j];
                                        arr[j] = arr[j+1];
                                        arr[j+1] = temp;
                                    }
                                }
                                end--;
                                i++;
                            }
                            else
                            {
                                for(int j = end;j>start;j--)
                                {
                                    if(arr[j] < arr[j-1])
                                    {
                                        temp = arr[j];
                                        arr[j] = arr[j-1];
                                        arr[j-1] = temp;
                                    }
                                }
                                start++;
                                i++;
                            }
                        }
                    }

Counting sort

Make a count array with length = the largest element of the array to be sorted.
Pick each element from the given array and update the count array(keep the count of each element).
Make prefix sum of the count array.
Iterate through the given array , with each value as key of the count array, pick the value from the count array, now using this value as key put the value of the original array in a new output array.
Check code for proper understanding.

                    counting_sort(){
                        let arr2 = [];
                        for(let i = 0;i<=460;i++)
                            arr2[i] = 0;
                    
                        for(let i = 0;i<l;i++)
                            arr2[arr[i]]++;
                    
                        for(let i = 1;i<=460;i++)
                            arr2[i]=arr2[i-1]+arr2[i];
                    
                    
                        let arr3 = [];
                        let j = 0;
                        for(let i = 0;i<l;i++)
                        {
                            let val = arr2[arr[i]];
                            arr3[val] = arr[i];
                            arr2[arr[i]]--;
                        }
                    
                        for(let i = 0;i<l;i++)
                            arr[i] = arr3[i+1];
                    }

Radix sort

Pick the ones placevalue digit of all elements and perform counting sort.
Do the same with tens , hundreds .... till all the digits of the largest element is covered.
Other stable sorting algorithm can be used inplace of counting sort.

                    radix_sort()
                    {
                        for(let i = 0;i<3;i++)
                        {
                            let arr2 = [];
                            for(let j = 0;j<10;j++)
                                arr2[j] = 0;
                            
                            for(let j = 0;j<l;j++)
                            {
                                let digit = Math.floor(arr[j]/(10**i))%10;
                                arr2[digit]++;
                            }

                            for(let j = 1;j<10;j++)
                                arr2[j] = arr2[j]+arr2[j-1];
                    
                            let arr3 = [];
                            for(let j = l-1;j>=0;j--)
                            {
                                let digit = Math.floor(arr[j]/(10**i))%10;
                                let value = arr2[digit];
                                arr3[value] = arr[j];
                                arr2[digit]--;
                            }
                            for(let j = 0;j<l;j++)
                            {
                                arr[j] = arr3[j+1];   
                            }
                        }
                    }

Sorting Simplified

Readme

Bubble sort

Insertion sort

Selection sort

Shell sort

Cocktail sort

Counting sort

Radix sort