Tóm Tắt

# Insertion Sort Java With Code Examples

Insertion Sort Java With Code Examples

The solution to Insertion Sort Java will be demonstrated using examples in this article.

```// Insertion sort in Java
import java.util.Arrays;
class InsertionSort {
void insertionSort(int array[]) {
int size = array.length;
for (int step = 1; step < size; step++) {
int key = array[step];
int j = step - 1;
// Compare key with each element on the left of it until an element smaller than
// it is found.
// For descending order, change key<array[j] to key>array[j].
while (j >= 0 && key < array[j]) {
array[j + 1] = array[j];
--j;
}
// Place key at after the element just smaller than it.
array[j + 1] = key;
}
}
// Driver code
public static void main(String args[]) {
int[] data = { 9, 5, 1, 4, 3 };
InsertionSort is = new InsertionSort();
is.insertionSort(data);
System.out.println("Sorted Array in Ascending Order: ");
System.out.println(Arrays.toString(data));
}
}
```

To solve the same problem as Insertion Sort Java, you can also utilise the method that is discussed further down this page, along with several code samples.

```// Java Insertion Sort
// -------------------
/*
Time Complexity
Best Time Complexity:O(n)
Average Time Complexity:O(n^2)
Worst Time Complexity:O(n^2)
Space Complexity
No auxiliary space is required in Linear Search implementation.
Hence space complexity is:O(1)
*/
import java.util.Arrays;
import java.util.Scanner;
public class InsertionSort {
public static int[] sort(int arr[]) {
for (int i = 0; i < arr.length; i++) {
int j = i - 1; // j will point to previous element
int k = arr[i]; // k holds the value being sorted
while (j >= 0 && k <= arr[j]) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = k;
}
return arr; //returns the sorted array
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int arr[] = new int[10];
System.out.println("Enter Array Values: ");
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
int a[] = new int[arr.length];
a = Arrays.copyOf(sort(arr), arr.length); //copies the sorted array to another array
//sorted in ascending order
System.out.println("Sorted Array:");
for (int i = 0; i < a.length; i++) {
System.out.print(+a[i] + " ");
}
}
}
```

We’ve shown how to use programming to solve the Insertion Sort Java problem with a slew of examples.

## What is insertion sort in Java?

Insertion sort is a simple sorting algorithm that allows for efficient, in-place sorting of the array, one element at a time. By in-place sorting, we mean that the original array is modified and no temporary structures are needed. We will learn how to implement this style of sorting in Java.

## What is insertion sort with example?

Insertion sort is a simple sorting algorithm that works similar to the way you sort playing cards in your hands. The array is virtually split into a sorted and an unsorted part. Values from the unsorted part are picked and placed at the correct position in the sorted part.13-Jul-2022

## Why insertion sort is used?

Insertion sort has a fast best-case running time and is a good sorting algorithm to use if the input list is already mostly sorted. For larger or more unordered lists, an algorithm with a faster worst and average-case running time, such as mergesort, would be a better choice.

## How insertion sort is done?

Working of Insertion Sort

• The first element in the array is assumed to be sorted. Take the second element and store it separately in key .
• Now, the first two elements are sorted. Take the third element and compare it with the elements on the left of it.
• Similarly, place every unsorted element at its correct position.

## Which one is real example of insertion sort?

One more real-world example of insertion sort is how tailors arrange shirts in a cupboard, they always keep them in sorted order of size and thus insert new shirts at the right position very quickly by moving other shirts forward to keep the right place for a new shirt.

## What is first step in insertion sort?

Insertion Algorithms: Steps on how it works:

• If it is the first element, it is already sorted.
• Pick the next element.
• Compare with all the elements in sorted sub-list.
• Shift all the the elements in sorted sub-list that is greater than the value to be sorted.
• Insert the value.
• Repeat until list is sorted.

## What is the difference between insertion sort and selection sort?

Insertion sort is a simple sorting algorithm that builds the final sorted list by transferring one element at a time. Selection sort, in contrast, is a simple sorting algorithm that repeatedly searches remaining items to find the smallest element and moves it to the correct location.10-May-2019

## Is insertion sort inplace?

Ans. Yes, Insertion sort is both an inplace and a stable algorithm. Insertion sort is a stable algorithm since equal elements remain the same in the sorted array as that of the unsorted array. It is also an inplace algorithm as only a constant number of extra variables is used to store the current element.23-Mar-2022

## Why insertion sort is better than selection sort?

Insertion sort’s advantage is that it only scans as many elements as it needs in order to place the k+1st element, while selection sort must scan all remaining elements to find the k+1st element. Experiments show that insertion sort usually performs about half as many comparisons as selection sort.