Sorteringsalgoritme

I denne veiledningen vil du lære hvordan sortering av innsetting fungerer. Du vil også finne eksempler på innsetting i C, C ++, Java og Python.

Innsettingssortering fungerer på samme måte som vi sorterer kort i hånden vår i et kortspill.

Vi antar at det første kortet allerede er sortert da, vi velger et usortert kort. Hvis det usorterte kortet er større enn kortet i hånden, plasseres det til høyre ellers til venstre. På samme måte blir andre usorterte kort tatt og satt på riktig sted.

En lignende tilnærming brukes ved innsettingssortering.

Innsettingssortering er en sorteringsalgoritme som plasserer et usortert element på sitt passende sted i hver iterasjon.

Hvordan fungerer innsettingssortering?

Anta at vi trenger å sortere følgende matrise.

Innledende matrise

1. Det første elementet i matrisen antas å være sortert. Ta det andre elementet og oppbevar det separat i key.
   Sammenlign keymed det første elementet. Hvis det første elementet er større enn key, plasseres nøkkelen foran det første elementet. Hvis det første elementet er større enn nøkkelen, plasseres nøkkelen foran det første elementet.
2. Nå er de to første elementene sortert.
   Ta det tredje elementet og sammenlign det med elementene til venstre for det. Plasserte den like bak elementet mindre enn det. Hvis det ikke er noe mindre enn det, så plasser det i begynnelsen av matrisen. Plasser 1 i begynnelsen
3. På samme måte plasserer hvert usortert element i riktig posisjon. Plass 4 bak 1 Plass 3 bak 1, og matrisen sorteres

Sorteringsalgoritme

 insertionSort (array) markerer det første elementet som sortert for hvert usorterte element X 'trekker ut' elementet X for j X flytter det sorterte elementet til høyre med en bremsesløyfe og setter X her slutten innsettingSort

Python, Java og C / C ++ eksempler

Python Java C C ++

 # Insertion sort in Python def insertionSort(array): for step in range(1, len(array)): key = array(step) 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 keyarray(j). while j>= 0 and key < array(j): array(j + 1) = array(j) j = j - 1 # Place key at after the element just smaller than it. array(j + 1) = key data = (9, 5, 1, 4, 3) insertionSort(data) print('Sorted Array in Ascending Order:') print(data)

  // 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 keyarray(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)); ) )

 // Insertion sort in C #include // Function to print an array void printArray(int array(), int size) ( for (int i = 0; i < size; i++) ( printf("%d ", array(i)); ) printf(""); ) void insertionSort(int array(), int size) ( 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 keyarray(j). while (key = 0) ( array(j + 1) = array(j); --j; ) array(j + 1) = key; ) ) // Driver code int main() ( int data() = (9, 5, 1, 4, 3); int size = sizeof(data) / sizeof(data(0)); insertionSort(data, size); printf("Sorted array in ascending order:"); printArray(data, size); )

 // Insertion sort in C++ #include using namespace std; // Function to print an array void printArray(int array(), int size) ( for (int i = 0; i < size; i++) ( cout << array(i) << " "; ) cout << endl; ) void insertionSort(int array(), int size) ( 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 keyarray(j). while (key = 0) ( array(j + 1) = array(j); --j; ) array(j + 1) = key; ) ) // Driver code int main() ( int data() = (9, 5, 1, 4, 3); int size = sizeof(data) / sizeof(data(0)); insertionSort(data, size); cout << "Sorted array in ascending order:"; printArray(data, size); )

Kompleksitet

Tidskompleksiteter

• Verste sakskompleksitet: Anta at en matrise er i stigende rekkefølge, og du vil sortere den i synkende rekkefølge. I dette tilfellet oppstår kompleksitet i verste fall. Hvert element må sammenlignes med hvert av de andre elementene, så for hvert nte element blir antall sammenligninger gjort. Dermed er det totale antallet sammenligninger =O(n2)

(n-1)
n*(n-1) ~ n2
• Best case-kompleksitet: O(n)
  Når matrisen allerede er sortert, kjører den ytre sløyfen nflere ganger mens den indre sløyfen ikke kjører i det hele tatt. Så det er bare nantall sammenligninger. Dermed er kompleksitet lineær.
• Gjennomsnittlig sakskompleksitet: Det oppstår når elementene i en matrise er i rotet rekkefølge (verken stigende eller synkende).O(n2)

Romkompleksitet

Romkompleksitet er O(1)fordi det brukes en ekstra variabel key.

Sorteringsprogrammer for innsetting

Innsettingssorten brukes når:

• matrisen er har et lite antall elementer
• det er bare noen få elementer igjen som skal sorteres