Answers for "Insertion Sort"

insertion sort

#insertion sort
def insert(arr):
    for i in range(1,len(arr)):
        while arr[i-1] > arr[i] and i > 0:
            arr[i], arr[i-1] = arr[i-1], arr[i]
            i -= 1 
    return arr 
arr = [23, 55, 12, 99, 66, 33]
print(insert(arr))

insertion sort

//I Love Java
import java.util.*;
import java.io.*;
import static java.util.stream.Collectors.toList;
import java.util.stream.*;

public class Insertion_Sort_P {
    public static void main(String[] args) throws IOException {
        BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));

        List<Integer> arr = Stream.of(buffer.readLine().replaceAll("\\s+$", " ").split(" ")).map(Integer::parseInt)
                .collect(toList());

        insertion_sort(arr);

        System.out.println(arr);
    }

    public static void insertion_sort(List<Integer> arr) {
        for (int i = 1; i <= arr.size() - 1; i++) {
            steps(arr, i);
        }
    }

    public static void steps(List<Integer> arr, int comp) {
        for (int i = 0; i <= comp - 1; i++) {
            if (arr.get(comp) < arr.get(i)) {
                swap(arr, i, comp);
            }
        }
    }

    static void swap(List<Integer> arr, int i, int j) {
        int temp = arr.get(i);
        arr.set(i, arr.get(j));
        arr.set(j, temp);
    }
}

insertion sort

def insertionSort(arr): 
    for i in range(1, len(arr)): 
        key = arr[i] 
        j = i-1
        while j >= 0 and key < arr[j] : 
                arr[j + 1] = arr[j] 
                j -= 1
        arr[j + 1] = key

insertion sort

#include <bits/stdc++.h>

using namespace std; 

void insertionSort(int arr[], int n)  
{  
    int i, temp, j;  
    for (i = 1; i < n; i++) 
    {  
        temp = arr[i];  
        j = i - 1;  

        while (j >= 0 && arr[j] > temp) 
        {  
            arr[j + 1] = arr[j];  
            j = j - 1;  
        }  
        arr[j + 1] = temp;  
    }  
}

int main()  
{  
    int arr[] = { 1,4,2,5,333,3,5,7777,4,4,3,22,1,4,3,666,4,6,8,999,4,3,5,32 };  
    int n = sizeof(arr) / sizeof(arr[0]);  

    insertionSort(arr, n);  

    for(int i = 0; i < n; i++){
        cout << arr[i] << " ";
    }

    return 0;  
}

insertion sort

// Por ter uma complexidade alta,
// não é recomendado para um conjunto de dados muito grande.
// Complexidade: O(n²) / O(n**2) / O(n^2)
// @see https://www.youtube.com/watch?v=TZRWRjq2CAg
// @see https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html

function insertionSort(vetor) {
    let current;
    for (let i = 1; i < vetor.length; i += 1) {
        let j = i - 1;
        current = vetor[i];
        while (j >= 0 && current < vetor[j]) {
            vetor[j + 1] = vetor[j];
            j--;
        }
        vetor[j + 1] = current;
    }
    return vetor;
}

insertionSort([1, 2, 5, 8, 3, 4])

insertion sort

//insertion sort
#include <iostream>

using namespace std;
void insertion_sort(int arr[],int n)
{
    int value,index;
    for(int i=1;i<n;i++)
    {
        value=arr[i];
        index=i;
        while(index>0&&arr[index-1]>value)
        {
            arr[index]=arr[index-1];
            index--;

        }
        arr[index]=value;
    }
}
void display(int arr[],int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
}

int main()
{
    int n;
    cout<<"enter the size of the array:"<<endl;
    cin>>n;
    int array_of_numbers[n];
    cout<<"enter the elements of the array:"<<endl;
    for(int i=0;i<n;i++)
    {
        cin>>array_of_numbers[i];
    }
    cout<<"array before sorting:"<<endl;
    display(array_of_numbers,n);
    insertion_sort(array_of_numbers,n);
    cout<<"array after sorting is:"<<endl;
    display(array_of_numbers,n);

    return 0;
}

insertion sort

function insertionSortIterativo(array A)
     for i ← 1 to length[A] 
       do value ← A[i]
            j ← i-1
        while j >= 0 and A[j] > value 
          do A[j + 1] ← A[j]
             j ← j-1
        A[j+1] ← value;

Insertion Sort

class Sort  
{ 
    static void insertionSort(int arr[], int n) 
    { 
        if (n <= 1)                             //passes are done
        {
            return; 
        }

        insertionSort( arr, n-1 );        //one element sorted, sort the remaining array
       
        int last = arr[n-1];                        //last element of the array
        int j = n-2;                                //correct index of last element of the array
       
        while (j >= 0 && arr[j] > last)                 //find the correct index of the last element
        { 
            arr[j+1] = arr[j];                          //shift section of sorted elements upwards by one element if correct index isn't found
            j--; 
        } 
        arr[j+1] = last;                            //set the last element at its correct index
    } 

    void display(int arr[])                 //display the array
    {  
        for (int i=0; i<arr.length; ++i) 
        {
            System.out.print(arr[i]+" ");
        } 
    } 
 
       
    public static void main(String[] args) 
    { 
        int arr[] = {22, 21, 11, 15, 16}; 
       
        insertionSort(arr, arr.length); 
        Sort ob = new Sort();
        ob.display(arr); 
    } 
}

insertion sort

function insertionSortRicorsivo(array A, int n)
     if n>1
        insertionSortRicorsivo(A,n-1)
        value ← A[n-1]
        j ← n-2
        while j >= 0 and A[j] > value 
         do A[j + 1] ← A[j]
            j ← j-1
        A[j+1] ← value