Updated March 17, 2023

## Introduction to Sorting Algorithms in Java

To sort the information in a certain order, often within an array-like framework, is to arrange them. You can use different sequence requirements; popular ones are sorting numbers from least to biggest or vice versa, or lexicographically sorting strings. We will cover different algorithms, from ineffective but intuitive alternatives through to efficient algorithms effectively implemented in Java and in other languages if you are interested in how sorting is to work.

### Different sorting algorithms in java

There are different sorting algorithms, and not all of them are equally effective. In order to compare them and see which ones perform best, we will analyze their time complexities.

- Insertion Sort
- Bubble Sort
- Selection Sort
- Merge Sort
- Heapsort

#### 1. Insertion Sort

The concept behind Insertion Sort divides the range into subarrays that are sorted and unsorted. The classified portion is at the start of duration 1 and matches the first (left side) component in the array. We move through the array and expand the classified part of the array by one component during every iteration. When we expand, we position the fresh element in the sorted sub-array. We do this by moving all the elements to the right until we find that we don’t have to change the first component. When the bold portion is sorted in ascending order, for instance, in the following array, it occurs:

- 3 5 7 8 4 2 1 9 6: Consider 4 and inserting this is what we need. We’ve been shifting since 8 > 4
- 2. 3 5 7 x 8 2 1 9 6
- 3 5 x 7 8 2 1 9 6
- 3 x 5 7 8 2 1 9 6
- 3 4 5 7 8 2 1 9 6

**Code:**

```
public class InsertionSortEx {
public static void insertionSort(int[] arr) {
for (int x = 1; x < arr.length; x++) {
int current = arr[x];
int y = x - 1;
while(y >= 0 && current < arr[y]) {
arr[y+1] = arr[y];
y--;
}
arr[y+1] = current;
}
}
public static void main(String a[]){
int[] arr1 = {3,5,7,8,4,2,1,9,6};
System.out.println("Before Sorting");
for(int x:arr1){
System.out.print(x+" ");
}
System.out.println();
insertionSort(arr1);//sorting array using insertion sort
System.out.println("After Insertion Sorting");
for(int x:arr1){
System.out.print(x+" ");
}
}
}
```

**Output:**

Following this method, one component extended the sorted part; we now have five instead of four elements. Every iteration does this, and the whole array will be sorted by the end.

**Note:**This is because we need to transfer the whole classified list one by one in each iteration, which is O(n). We must do this for each component in each table, which implies that it is O(n^2) bounded.2.

#### 2. Bubble Sort

If the bubble is not in the required order, it operates by replacing neighboring components. This is repeated until all components are in order from the start of the array. We know that if we manage to do the entire iteration without swaps, all items compared with their adjacent elements were in the desirable order and, by extension, the whole array. The reason for the Bubble Sort algorithm is that the numbers like “bubbles up” into the “ground.” If, after a specific amount, you go through the instance again (4 is a good instance), you will notice that the number slowly moves to the right.

Steps to Bubble Sorting are as follows:

**4 2**1 5 3: Here, 1^{st}two numbers are not in the right order; hence we have to sort both the numbers.- 2
**4 1**5 3: After that, the next pair of number is also not in the right order. So sorting occurs again. - 2 1
**4 5**3: These two are in the right order, 4 < 5, hence there is no need to swap them. - 2 1 4
**5 3**: Again, we have to swap for proper order. - 2 1 4 3 5: Here’s the resulting array after one iteration.
- We have to repeating this process again until the numbers are in proper order.

**Code:**

```
public class BubbleSortExample {
public static void bubbleSort(int[] arr) {
int n = arr.length;
int tmp = 0;
for(int x=0; x < n; x++){
for(int y=1; y < (n-x); y++){
if(arr[y-1] > arr[y]){
//swap elements
tmp = arr[y-1];
arr[y-1] = arr[y];
arr[y] = tmp;
}
}
}
}
public static void main(String[] args) {
int arr[] ={4,2,1,5,3};
System.out.println("Array Before Bubble Sort");
for(int x=0; x < arr.length; x++){
System.out.print(arr[x] + " ");
}
System.out.println();
bubbleSort(arr);
System.out.println("Array After Bubble Sort");
for(int x=0; x < arr.length; x++){
System.out.print(arr[x] + " ");
}
}
}
```

**Output:**

**Note:**It might have ended up in an infinite loop if I used a[i]>= a[i+1 ] because that connection would still be valid with equivalent components and thus always swap them from one element to another.

#### 3. Selection Sort

Selection Sort splits the array into an array of classifications that are not sorted. This time, however, the sorting subarray is formed by inserting at the end of the sorted array the minimum element of the unsorted subarray by swapping:

- 3 5
*1*2 4 **1**5 3*2*4**1 2***3*5 4**1 2 3**5*4***1 2 3 4***5***1 2 3 4 5**

**Code:**

```
public class SelectionSortEx {
public static void selectionSort(int[] arr){
for (int x = 0; x < arr.length - 1; x++)
{
int indx = x;
for (int y = x + 1; y < arr.length; y++){
if (arr[y] < arr[indx]){
indx = y;
}
}
int smallNumber = arr[indx];
arr[indx] = arr[x];
arr[x] = smallNumber;
}
}
public static void main(String a[]){
int[] arr1 = {3,5,1,2,4};
System.out.println("Before Sorting");
for(int x:arr1){
System.out.print(x+" ");
}
System.out.println();
selectionSort(arr1);
System.out.println("After Selection Sorting");
for(int x:arr1){
System.out.print(x+" ");
}
}
}
```

**Output:**

**Note:**The minimum is O(n) for the array size because all the components must be checked. For each element of the array, we must find the minimum and make the whole process O (n^2) limited.

#### 4. Merge Sort

Merge Sort utilizes recursion to fix the issue of the divide and conquest method more effectively than earlier described algorithms.

This tree shows how the recursive calls function. Down arrow marked arrays are the arrays for which we call function while we fuse up arrow arrays. Then you follow the arrow to the tree’s edge and then return and merge. We’ve got 3 5 3 1 range, so we split it into 3 5 4 and 2 1. We split them into their parts in order to sort them. We begin fusioning and sorting them as we go when we get to the bottom.

**Code:**

```
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
public class MergeSort {
static void merge(int[] array,int lowval,int midval,int highval){
int x, y ,k;
int[] c= new int[highval-lowval+1];
k = 0;
x=lowval;
y=midval+1;
while(x<=midval && y<=highval){
if(array[x]<=array[y]){
c[k++] = array[x++];
}
else{
c[k++] = array[y++];
}
}
while(x<=midval){
c[k++] = array[x++];
}
while(y<=highval){
c[k++] = array[y++];
}
k=0;
for(x = lowval; x<=highval; x++){
array[x] = c[k++];
}
}
static void mergeSort(int[] array,int lowval, int highval){
if(highval-lowval+1>1){
int midval = (lowval+highval)/2;
mergeSort(array,lowval,midval);
mergeSort(array,midval+1,highval);
merge(array,lowval,midval,highval);
}
}
public static void main(String[] args) {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
int size;
System.out.println("Enter the array");
try {
size = Integer.parseInt(r.readLine());
} catch (Exception e) {
System.out.println("Please Enter valid Input");
return;
}
int[] array = new int[size];
System.out.println("Enter array elements");
int x;
for (x = 0; x < array.length; x++) {
try {
array[x] = Integer.parseInt(r.readLine());
} catch (Exception e) {
System.out.println("An error Occurred");
}
}
System.out.println("After Sorting");
System.out.println(Arrays.toString(array));
mergeSort(array,0,array.length-1);
System.out.println("Before Merge Sorting");
System.out.println(Arrays.toString(array));
}
}
```

In this program, we have asked the user to enter input. The output will be in sorted order based on the user’s input.

**Output:**

#### 5. Heap Sort

You first must know the framework on which Heapsort operates-the heap-in order to comprehend why it operates. We will specifically speak about a binary heap, but you can also generalize this to other heap constructions. A heap is a tree that fulfills the property of the heap, namely that all its kids have relationships to each node. A heap must also be nearly finished. A near-complete d-depth binary has a d-1 subtree with the same root, and each node has a full, left subtree, with a left descending.

In other words, you get a lower and lower number (min-heap) or larger and bigger (max-heap) when moving down the tree. Here is a max-heap instance:

- 6 1 8 3 5
**2 4**: Here, Both children’s numbers are smaller than the parent; hence we do not have to change anything. - 6 1 8
**3 5**2 4: Here, 5 > 1, we need to swap them. We need to heapify for 5. - 6 5 8
**3 1**2 4: Both of the children’s numbers are smaller; everything remains the same. - 6
**5 8**3 1 2 4: Here, 8 > 6, hence we should swap them. - 8 5 6 3 1 2 4: After this iteration, we will get this result.

After Repeating this process again, we will get the following results:

- 8 5 6 3 1 2 4

- 4 5 6 3 1 2
**8**: Swapping - 6 5 4 3 1 2
**8**: Heapify - 2 5 4 3 1
**6 8**: Swapping - 5 2 4 2 1
**6 8**: Heapify - 1 2 4 2
**5 6 8**: Swapping

**Code:**

```
public class HeapSort
{
public void sort(int arr[])
{
int n = arr.length;
for (int x = n / 2 - 1; x >= 0; x--)
heapify(arr, n, x);
for (int x=n-1; x>=0; x--)
int tmp = arr[0];
arr[0] = arr[x];
arr[x] = tmp;
heapify(arr, x, 0);
}
}
void heapify(int arr[], int n, int x)
{
int largest = x;
int L = 2*x + 1;
int r = 2*x + 2;
if (L < n && arr[L] > arr[largest])
largest = L;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != x)
{
int swap = arr[x];
arr[x] = arr[largest];
arr[largest] = swap;
heapify(arr, n, largest);
}
}
static void printArray(int arr[])
{
int n = arr.length;
for (int x=0; x<n; ++x)
System.out.print(arr[x]+" ");
System.out.println();
}
public static void main(String args[])
{
int arr[] = {6,1,8,3,5,2,4};
int n = arr.length;
System.out.println("Before Sorting:");
printArray(arr);
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("After Heap Sorting:");
printArray(arr);
}
}
```

**Output:**

You can view it from point to level of the graph, from left to right. We achieved here that when we have the kth component in the array, the position of its children is 2\*k+1 and 2\*k+2 (assuming that indexing begins at 0). You can monitor this. The position of the parent is always (k-1)/2 for the kth component. You can readily “max heap up” any range because you know that. Check whether one of its kids is lower than that for each component. If so, pair one parent and repeat this step recursively with the parent.

**Note:**Since iterating for-loops across the entire array makes heapSort) (obviously O(N), it would create Heapsort O’s overall complexity(nlog n). Heapsort has an on-the-spot type, which means that it requires O(1) more room than Merge Sort, but it has some disadvantages, such as parallels that are hard.

### Conclusion – Sorting Algorithms in Java

Sorting is a very prevalent procedure with datasets, whether for further analysis, speeding search with more effective algorithms relying on sorted information, filtering information, etc. Several languages endorse sorting, and often the interfaces obscure what the programmer does.

### Recommended Articles

This is a guide to Sorting Algorithms in Java. Here we discuss different types of sorting in Java along with their algorithms. You can also go through our other suggested articles –