logo

TechCodeview

Insertion Sort – Structura datelor și Tutoriale de algoritm

Sortare prin inserare este un algoritm de sortare simplu care funcționează prin inserarea iterativă a fiecărui element dintr-o listă nesortată în poziția sa corectă într-o porțiune sortată a listei. Este un sortare stabilă algoritm, ceea ce înseamnă că elementele cu valori egale își mențin ordinea relativă în rezultatul sortat.

Sortare prin inserare este ca și cum ai sorta cărțile de joc în mâinile tale. Împărțiți cărțile în două grupuri: cărțile sortate și cărțile nesortate. Apoi, alegeți un card din grupul nesortat și îl puneți la locul potrivit în grupul sortat.



Algoritm de sortare prin inserare:

Sortare prin inserare este un algoritm de sortare simplu care funcționează prin construirea unui tablou sortat câte un element. Este considerat un la loc algoritm de sortare, ceea ce înseamnă că nu necesită spațiu de memorie suplimentar în afara matricei originale.

Algoritm:

Pentru a realiza sortarea prin inserare, urmați acești pași:



natasha dalal
  • Trebuie să începem cu al doilea element al matricei, deoarece primul element din matrice se presupune a fi sortat.
  • Comparați al doilea element cu primul element și verificați dacă al doilea element este mai mic, apoi schimbați-le.
  • Treceți la al treilea element și comparați-l cu al doilea element, apoi cu primul element și schimbați după cum este necesar pentru a-l pune în poziția corectă între primele trei elemente.
  • Continuați acest proces, comparând fiecare element cu cele dinaintea lui și schimbând după cum este necesar pentru a-l plasa în poziția corectă printre elementele sortate.
  • Repetați până când întreaga matrice este sortată.

Funcționarea algoritmului de sortare prin inserție:

Luați în considerare o matrice care are elemente : {23, 1, 10, 5, 2}

Prima trecere:



  • Elementul curent este 23
  • Se presupune că primul element din matrice este sortat.
  • Partea sortată până la al 0-lea indicele este: [23]

A doua trecere:

  • Comparaţie 1 cu 23 (element curent cu partea sortată).
  • De cand 1 este mai mic, introduceți 1 inainte de 23 .
  • Partea sortată până la 1 indicele este: [1, 23]

A treia trecere:

fonturi pentru gimp
  • Comparaţie 10 cu 1 și 23 (element curent cu partea sortată).
  • De cand 10 este mai mare decât 1 si mai mic decat 23 , introduceți 10 între 1 și 23 .
  • Partea sortată până la al 2-lea indicele este: [1, 10, 23]

A patra trecere:

  • Comparaţie 5 cu 1 , 10 , și 23 (element curent cu partea sortată).
  • De cand 5 este mai mare decât 1 si mai mic decat 10 , introduceți 5 între 1 și 10 .
  • Partea sortată până la al 3-lea indicele este : [1, 5, 10, 23]

A cincea trecere:

  • Comparaţie 2 cu 1, 5, 10 , și 23 (element curent cu partea sortată).
  • De cand 2 este mai mare decât 1 si mai mic decat 5 introduce 2 între 1 și 5 .
  • Partea sortată până la al 4-lea indicele este: [1, 2, 5, 10, 23]

Matrice finală:

  • Matricea sortată este: [1, 2, 5, 10, 23]
Practică recomandată Inserare Sortare Încercați!

Implementarea sortării inserției:

C++ 
// C++ program for insertion sort #include  using namespace std; // Function to sort an array using // insertion sort void insertionSort(int arr[], int n) {  int i, key, j;  for (i = 1; i < n; i++) {  key = arr[i];  j = i - 1;  // Move elements of arr[0..i-1],  // that are greater than key,   // to one position ahead of their  // current position  while (j>= 0 && arr[j]> tastă) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = cheie;  } } // O funcție utilitar pentru a imprima o matrice // de dimensiunea n void printArray(int arr[], int n) { int i;  pentru (i = 0; i< n; i++)  cout << arr[i] << ' ';  cout << endl; } // Driver code int main() {  int arr[] = { 12, 11, 13, 5, 6 };  int N = sizeof(arr) / sizeof(arr[0]);  insertionSort(arr, N);  printArray(arr, N);  return 0; } // This is code is contributed by rathbhupendra>
C 
// C program for insertion sort #include  #include  /* Function to sort an array using insertion sort*/ void insertionSort(int arr[], int n) {  int i, key, j;  for (i = 1; i < n; i++) {  key = arr[i];  j = i - 1;  /* Move elements of arr[0..i-1], that are  greater than key, to one position ahead  of their current position */  while (j>= 0 && arr[j]> tastă) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = cheie;  } } // O funcție utilitar pentru a tipări o matrice de dimensiunea n void printArray(int arr[], int n) { int i;  pentru (i = 0; i< n; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver program to test insertion sort */ int main() {  int arr[] = { 12, 11, 13, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  insertionSort(arr, n);  printArray(arr, n);  return 0; }>
Java 
// Java program for implementation of Insertion Sort public class InsertionSort {  /*Function to sort array using insertion sort*/  void sort(int arr[])  {  int n = arr.length;  for (int i = 1; i < n; ++i) {  int key = arr[i];  int j = i - 1;  /* Move elements of arr[0..i-1], that are  greater than key, to one position ahead  of their current position */  while (j>= 0 && arr[j]> tastă) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = cheie;  } } /* O funcție utilitar pentru a tipări o matrice de dimensiunea n*/ static void printArray(int arr[]) { int n = arr.length;  pentru (int i = 0; i< n; ++i)  System.out.print(arr[i] + ' ');  System.out.println();  }  // Driver method  public static void main(String args[])  {  int arr[] = { 12, 11, 13, 5, 6 };  InsertionSort ob = new InsertionSort();  ob.sort(arr);  printArray(arr);  } }; /* This code is contributed by Rajat Mishra. */>
Piton 
# Python program for implementation of Insertion Sort # Function to do insertion sort def insertionSort(arr): # Traverse through 1 to len(arr) for i in range(1, len(arr)): key = arr[i] # Move elements of arr[0..i-1], that are # greater than key, to one position ahead # of their current position j = i-1 while j>= 0 și cheie< arr[j] : arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key # Driver code to test above arr = [12, 11, 13, 5, 6] insertionSort(arr) for i in range(len(arr)): print ('% d' % arr[i]) # This code is contributed by Mohit Kumra>
C# 
// C# program for implementation of Insertion Sort using System; class InsertionSort {  // Function to sort array  // using insertion sort  void sort(int[] arr)  {  int n = arr.Length;  for (int i = 1; i < n; ++i) {  int key = arr[i];  int j = i - 1;  // Move elements of arr[0..i-1],  // that are greater than key,  // to one position ahead of  // their current position  while (j>= 0 && arr[j]> tasta) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = cheie;  } } // O funcție utilitar pentru a imprima // matrice de dimensiune n static void printArray(int[] arr) { int n = arr.Length;  pentru (int i = 0; i< n; ++i)  Console.Write(arr[i] + ' ');  Console.Write('
');  }  // Driver Code  public static void Main()  {  int[] arr = { 12, 11, 13, 5, 6 };  InsertionSort ob = new InsertionSort();  ob.sort(arr);  printArray(arr);  } } // This code is contributed by ChitraNayal.>
Javascript 
>>>PHP>>>  
  Ieșire      Complexitatea timpului:    O(N^2)  
    Spațiu auxiliar:    O(1)
 
 Analiza complexității sortării inserției :
    Timp Complexitatea sortării inserției    
  •     Cel mai bun caz:         Pe)    , Dacă lista este deja sortată, unde n este numărul de elemente din listă.
  •     Caz mediu:         Pe       2       )    , Dacă lista este ordonată aleatoriu
  •     Cel mai rău caz:         Pe       2       )    , Dacă lista este în ordine inversă
Complexitatea spațială    de sortare de inserare    
  •     Spațiu auxiliar:    O(1), sortarea inserării necesită    O(1)    spațiu suplimentar, făcându-l un algoritm de sortare eficient din punct de vedere al spațiului.
Avantaje    de sortare de inserare:    
  • Simplu și ușor de implementat.
  • Algoritm de sortare stabil.
  • Eficient pentru liste mici și liste aproape sortate.
  • Eficient din punct de vedere al spațiului.
Dezavantaje    de sortare de inserare:    
  • Ineficient pentru liste mari.
  • Nu este la fel de eficient ca alți algoritmi de sortare (de exemplu, sortare prin îmbinare, sortare rapidă) pentru majoritatea cazurilor.
Aplicații    de sortare de inserare:    
Sortarea prin inserare este folosită în mod obișnuit în situațiile în care:
 
  • Lista este mică sau aproape sortată.
  • Simplitatea și stabilitatea sunt importante.
Întrebări frecvente privind sortarea prin inserare
    Î1. Care sunt cazurile limită ale algoritmului de sortare prin inserare?    
  
Sortarea prin inserare necesită timp maxim pentru sortare dacă elementele sunt sortate în ordine inversă. Și este nevoie de timp minim (Ordinea lui n) când elementele sunt deja sortate.
 
    Q2. Care este Paradigma algoritmică a algoritmului de sortare prin inserție?    
centos vs redhat

  
Algoritmul Insertion Sort urmează o abordare incrementală.
 
    Q3. Insertion Sort este un algoritm de sortare in loc?    
  
Da, sortarea prin inserare este un algoritm de sortare pe loc.
 
    Î4. Este Insertion Sort un algoritm stabil?    
  
Da, sortarea prin inserare este un algoritm de sortare stabil.
 
    Î5. Când este folosit algoritmul de sortare prin inserare?    
  
Sortarea prin inserție este utilizată atunci când numărul de elemente este mic. Poate fi util și atunci când matricea de intrare este aproape sortată și doar câteva elemente sunt deplasate greșit într-o matrice mare completă.