├── sort.gif
├── .gitattributes
├── bubblesort.cpp
├── .gitignore
├── LICENSE.txt
├── HeapSort.java
├── readme.md
└── Sort.java


/sort.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/akshaybahadur21/Sort/HEAD/sort.gif


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/bubblesort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()  //Bubble Sort
 4 | {
 5 |     int a[7]={22,1,4,77,33,11,8},N=7,l=0;
 6 |     void swap(int*,int*);
 7 |     cout<<"Your array:\n";
 8 |     for(int i=0;i<N;i++)
 9 |         cout<<a[i]<<"\t";
10 |     cout<<endl;
11 |     cout<<"After Bubble sort\n";
12 |     for(int i=0;i<N;i++)
13 |     {
14 |         l=0;
15 |         for(int j=l;j<N-1;j++)
16 |         {
17 |             if(a[j]>a[j+1]){
18 |                 swap(&a[j],&a[j+1]);
19 |             }
20 |             l++;
21 |         }
22 |     }
23 | 
24 |     cout<<"\nUpdated array is:\n";
25 |     for(int i=0;i<N;i++)
26 |         cout<<a[i]<<"\t";
27 | 
28 |     return 0;
29 | }
30 | void swap(int *a,int *b )
31 | {
32 |     int c;
33 |     c=*a;
34 |     *a=*b;
35 |     *b=c;
36 | }
37 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Windows image file caches
 2 | Thumbs.db
 3 | ehthumbs.db
 4 | 
 5 | # Folder config file
 6 | Desktop.ini
 7 | 
 8 | # Recycle Bin used on file shares
 9 | $RECYCLE.BIN/
10 | 
11 | # Windows Installer files
12 | *.cab
13 | *.msi
14 | *.msm
15 | *.msp
16 | 
17 | # Windows shortcuts
18 | *.lnk
19 | 
20 | # =========================
21 | # Operating System Files
22 | # =========================
23 | 
24 | # OSX
25 | # =========================
26 | 
27 | .DS_Store
28 | .AppleDouble
29 | .LSOverride
30 | 
31 | # Thumbnails
32 | ._*
33 | 
34 | # Files that might appear in the root of a volume
35 | .DocumentRevisions-V100
36 | .fseventsd
37 | .Spotlight-V100
38 | .TemporaryItems
39 | .Trashes
40 | .VolumeIcon.icns
41 | 
42 | # Directories potentially created on remote AFP share
43 | .AppleDB
44 | .AppleDesktop
45 | Network Trash Folder
46 | Temporary Items
47 | .apdisk
48 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Akshay Bahadur
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/HeapSort.java:
--------------------------------------------------------------------------------
 1 | public class HeapSort 
 2 | { 
 3 |     public void sort(int arr[]) 
 4 |     { 
 5 |         int n = arr.length; 
 6 |   
 7 |         
 8 |         for (int i = n / 2 - 1; i >= 0; i--) 
 9 |             heapify(arr, n, i); 
10 |   
11 |         
12 |         for (int i=n-1; i>0; i--) 
13 |         { 
14 |              
15 |             int temp = arr[0]; 
16 |             arr[0] = arr[i]; 
17 |             arr[i] = temp; 
18 |   
19 |             
20 |             heapify(arr, i, 0); 
21 |         } 
22 |     } 
23 |   
24 |     
25 |     void heapify(int arr[], int n, int i) 
26 |     { 
27 |         int largest = i; // Initialize largest as root 
28 |         int l = 2*i + 1; // left = 2*i + 1 
29 |         int r = 2*i + 2; // right = 2*i + 2 
30 |   
31 |         
32 |         if (l < n && arr[l] > arr[largest]) 
33 |             largest = l; 
34 |   
35 |        
36 |         if (r < n && arr[r] > arr[largest]) 
37 |             largest = r; 
38 |   
39 |         
40 |         if (largest != i) 
41 |         { 
42 |             int swap = arr[i]; 
43 |             arr[i] = arr[largest]; 
44 |             arr[largest] = swap; 
45 |   
46 |             
47 |             heapify(arr, n, largest); 
48 |         } 
49 |     } 
50 |   
51 |     /* A utility function to print array of size n */
52 |     static void printArray(int arr[]) 
53 |     { 
54 |         int n = arr.length; 
55 |         for (int i=0; i<n; ++i) 
56 |             System.out.print(arr[i]+" "); 
57 |         System.out.println(); 
58 |     } 
59 |   
60 |     // Driver program 
61 |     public static void main(String args[]) 
62 |     { 
63 |         int arr[] = {12, 11, 13, 5, 6, 7}; 
64 |         int n = arr.length; 
65 |   
66 |         HeapSort ob = new HeapSort(); 
67 |         ob.sort(arr); 
68 |   
69 |         System.out.println("Sorted array is"); 
70 |         printArray(arr); 
71 |     } 
72 | } 
73 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | ## Sorting Algorithms 〽️
 2 | 
 3 | [![](https://img.shields.io/github/license/sourcerer-io/hall-of-fame.svg?colorB=ff0000)](https://github.com/akshaybahadur21/Sort/blob/master/LICENSE.txt)  [![](https://img.shields.io/badge/Akshay-Bahadur-brightgreen.svg?colorB=ff0000)](https://akshaybahadur.com)
 4 | 
 5 | This code helps you to understand the different Sorting algorithms. The sorting algorithms depicted in this code are:
 6 | 1) Bubble Sort
 7 | 2) Selection Sort
 8 | 3) Insertion Sort
 9 | 4) Quick Sort
10 | 5) Merge Sort
11 | 6) Heap Sort
12 | 
13 | ## Code Requirements 🦄
14 | The example code is in Java ([version 1.8](https://java.com/en/download/) or higher will work). 
15 | 
16 | ## Description ➿
17 | A sorting algorithm is an algorithm made up of a series of instructions that takes an array as input, performs specified operations on the array, sometimes called a list, and outputs a sorted array.
18 |  Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) which require input data to be in sorted lists; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions:
19 | 
20 |     The output is in nondecreasing order.
21 |     The output is a permutation (reordering) of the input.
22 | 
23 | 
24 | ```java
25 | 
26 | switch(ch)
27 | 		{
28 | 			case 1:
29 | 				BubbleSort(a,n);
30 | 				break;
31 | 			case 2:
32 | 				SelectionSort(a,n);
33 | 				break;
34 | 			case 3:
35 | 				InsertionSort(a,n);
36 | 				break;
37 | 			case 4:
38 | 				int start=0;
39 | 				int end=n-1;
40 | 				QuickSort(a,start,end);
41 | 				print(a,n);
42 | 				break;
43 | 			case 5:
44 | 				MergeSort(a,n);
45 | 				print(a,n);	
46 | 				break;
47 | 		}
48 | ``` 
49 | 
50 | 
51 | You can select any algorithm from the list and then enter an array which would get sorted through the selected algorithm.
52 | 
53 | ## Results 📊
54 | <img src="https://github.com/akshaybahadur21/Sort/blob/master/sort.gif">
55 | 
56 | 
57 | ## Execution 🐉
58 | To compile the code, simply run the `javac Sort.java`.
59 | To run the code, type `java Sort`
60 | 
61 | ```
62 | javac Sort.java
63 | java Sort
64 | ```
65 | 


--------------------------------------------------------------------------------
/Sort.java:
--------------------------------------------------------------------------------
  1 | import java.io.*;
  2 | import java.lang.*;
  3 | class Sort
  4 | {
  5 | 	public static void main(String args[])throws IOException
  6 | 	{
  7 | 		int ch;
  8 | 		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  9 | 		do
 10 | 	{
 11 | 		System.out.println("\n\n\n1.Bubble Sort\n2.Selection Sort\n3.Insertion Sort.\n4.Quick Sort.\n5.Merge Sort.\n6.Exit.");
 12 | 		 ch=Integer.parseInt(br.readLine());
 13 | 		if(ch==6)
 14 | 			return;
 15 | 		System.out.println("Enter n");
 16 | 		int n=Integer.parseInt(br.readLine());
 17 | 		int a[]=new int[n];
 18 | 		for(int i=0;i<n;i++)
 19 | 		{
 20 | 			a[i]=Integer.parseInt(br.readLine());
 21 | 		}
 22 | 		switch(ch)
 23 | 		{
 24 | 			case 1:
 25 | 				BubbleSort(a,n);
 26 | 				break;
 27 | 			case 2:
 28 | 				SelectionSort(a,n);
 29 | 				break;
 30 | 			case 3:
 31 | 				InsertionSort(a,n);
 32 | 				break;
 33 | 			case 4:
 34 | 				int start=0;
 35 | 				int end=n-1;
 36 | 				QuickSort(a,start,end);
 37 | 				print(a,n);
 38 | 				break;
 39 | 			case 5:
 40 | 				MergeSort(a,n);
 41 | 				print(a,n);	
 42 | 				break;
 43 | 		}
 44 | 		
 45 | 	}
 46 | 	while(ch!=6);
 47 | 	}
 48 | 	public static void BubbleSort(int a[],int n)
 49 | 	{
 50 | 		int temp;
 51 | 		boolean swap;
 52 | 		for(int i=0;i<n-1;i++)
 53 | 		{
 54 | 			swap=false;
 55 | 			for(int j=0;j<n-1;j++)
 56 | 			{
 57 | 				if(a[j]>a[(j+1)])
 58 | 				{
 59 | 					temp=a[j];
 60 | 					a[j]=a[(j+1)];
 61 | 					a[(j+1)]=temp;
 62 | 					swap=true;
 63 | 				}
 64 | 			//System.out.print(a[j]);
 65 | 			}
 66 | 			//System.out.println();
 67 | 			if(swap==false)
 68 | 				break;
 69 | 		}
 70 | 		print(a,n);
 71 | 	}
 72 | 	public static void SelectionSort(int a[], int n)
 73 | 	{
 74 | 		for (int i=0;i<n-1;i++)
 75 | 		{
 76 | 			int imin=i;
 77 | 			int temp;
 78 | 			for(int j=i+1;j<n;j++)
 79 | 			{
 80 | 				if(a[j]<a[imin])
 81 | 					imin=j;
 82 | 			}
 83 | 					temp=a[i];
 84 | 					a[i]=a[imin];
 85 | 					a[imin]=temp;
 86 | 		}
 87 | 		print(a,n);
 88 | 	}
 89 | 	public static void InsertionSort(int a[],int n)
 90 | 	{
 91 | 		for(int i=1;i<n;i++)
 92 | 		{
 93 | 			int val=a[i];
 94 | 			int hole=i;
 95 | 			while(hole>0&&a[hole-1]>val)
 96 | 			{
 97 | 				a[hole]=a[hole-1];
 98 | 				hole=hole-1;
 99 | 			}
100 | 			a[hole]=val;
101 | 		}
102 | 		print(a,n);
103 | 	}
104 | 	public static void MergeSort(int a[],int n)
105 | 	{
106 | 		
107 | 		if(n<=1)
108 | 			return;
109 | 		int mid=n/2;
110 | 		int left[]=new int[mid];
111 | 		int right[]=new int[n-mid];
112 | 		for(int i=0;i<mid;i++)
113 | 			left[i]=a[i];
114 | 		for(int i=mid;i<n;i++)
115 | 			right[i-mid]=a[i];
116 | 		MergeSort(left,mid);
117 | 		MergeSort(right,n-mid);
118 | 		Merge(left,right,a);
119 | 		
120 | 	}
121 | 	public static void Merge(int left[],int right[],int a[])
122 | 	{
123 | 		int nL=left.length;
124 | 		int nR=right.length;
125 | 		int i,j,k;
126 | 		i=j=k=0;
127 | 		while(i<nL&&j<nR)
128 | 		{
129 | 			if(left[i]<=right[j])
130 | 			{
131 | 				a[k]=left[i];
132 | 				i++;
133 | 				k++;
134 | 			}
135 | 			else
136 | 			{
137 | 				a[k]=right[j];
138 | 				j++;
139 | 				k++;
140 | 			}
141 | 		}
142 | 		while(i<nL)
143 | 		{
144 | 			a[k]=left[i];
145 | 			i++;
146 | 			k++;
147 | 		}
148 | 		while(j<nR)
149 | 		{
150 | 			a[k]=right[j];
151 | 			j++;
152 | 			k++;
153 | 		}
154 | 	}
155 | 	public static void QuickSort(int a[],int start,int end)
156 | 	{
157 | 		if(start<end)
158 | 		{
159 | 		int pIndex=QuickPartition(a,start,end);
160 | 		QuickSort(a,start,pIndex-1);
161 | 		QuickSort(a,pIndex+1,end);
162 | 		}
163 | 		else
164 | 			return;
165 | 		
166 | 	}
167 | 	public static int QuickPartition(int a[],int start,int end)
168 | 	{
169 | 		int temp;
170 | 		int pivot=a[end];
171 | 		int pIndex=start;
172 | 		for(int i=start;i<end;i++)
173 | 		{
174 | 			if(a[i]<=pivot)
175 | 			{
176 | 				//swap a[i],apindex
177 | 					temp=a[i];
178 | 					a[i]=a[pIndex];
179 | 					a[pIndex]=temp;
180 | 					pIndex++;
181 | 			}
182 | 		}
183 | 					temp=a[pIndex];
184 | 					a[pIndex]=a[end];
185 | 					a[end]=temp;
186 | 					return pIndex;
187 | 	}
188 | 	public static void print(int a[],int n)
189 | 	{
190 | 		System.out.println();
191 | 		for(int i=0;i<n;i++)
192 | 			System.out.print(a[i]+"\t");
193 | 	}
194 | }
195 | 


--------------------------------------------------------------------------------