Che cos'è l'ordinamento per inserzione in C?
Il metodo di ordinamento chiamato ordinamento per inserzione confronta ogni singolo elemento con quelli adiacenti mentre itera su un array. Un elemento più piccolo di quello che lo precede viene inserito nel sottoarray ordinato nella posizione appropriata.
Per illustrare ulteriormente, ho dimostrato un esempio in cui ho considerato un array di quattro elementi in un array come arr[]= {5, 4, 60, 9} e vogliamo ordinare questo elemento in ordine crescente utilizzando l'ordinamento per inserzione. Le seguenti interazioni spiegano l'esecuzione completa dell'ordinamento per inserzione:
Iterazione 1
| 5 | 4 | 60 | 9 |
Ora abbiamo un array come arr[5, 4, 60, 9], nella prima iterazione dell'ordinamento di inserimento confrontiamo prima i primi due elementi come 5 e 4, poiché arr[5] è > arr[4] quindi li scambiamo per ordinare l'array in ordine crescente. Ora, l'array sarà:
| 4 | 5 | 60 | 9 |
Iterazione 2
| 4 | 5 | 60 | 9 |
Nella seconda iterazione, confrontiamo i due elementi successivi, come arr[5] con arr[60].
Poiché arr[5] < arr[60], lo scambio non avviene poiché è già ordinato in ordine crescente. Ora l'array diventa:
| 4 | 5 | 60 | 9 |
Iterazione 3
| 4 | 5 | 60 | 9 |
Come nella terza iterazione, abbiniamo il terzo e il quarto elemento come arr[60] con arr[9].
Ora, vediamo che arr[60] > arr[9] si verifica quindi lo scambio, quindi l'array verrà ordinato in ordine crescente.
| 4 | 5 | 9 | 60 |
Questo è il modo in cui l'ordinamento per inserzione funziona in C che ordina facilmente un elemento dell'array in ordine crescente o decrescente.
Diagramma di flusso dell'ordinamento per inserzione
Di seguito è riportato il diagramma di flusso dell'algoritmo di ordinamento per inserzione:
Esempio di implementazione di Insertion Sort in C
Per prima cosa richiediamo una raccolta di elementi che devono essere ordinati in ordine decrescente e crescente per costruire il metodo di ordinamento per inserzione in C. Supponiamo, ai fini di questo esempio, di avere a che fare con un array di numeri {5, 4, 60, 9} :
#includevuoto Insertionsort_ascending ( int arr1 [ ] , int N ) {
int io , J , la mia chiave ;
//for loop viene utilizzato per iterare i valori i da 1 a i
per ( io = 1 ; io < N ; io ++ ) {
la mia chiave = arr1 [ io ] ;
J = io - 1 ;
Mentre ( J >= 0 && arr1 [ J ] > la mia chiave ) {
arr1 [ J + 1 ] = arr1 [ J ] ;
J = J - 1 ;
}
arr1 [ J + 1 ] = la mia chiave ;
}
}
vuoto insertorsort_descending ( int arr2 [ ] , int M ) {
int io , J , la mia chiave ;
//viene creato un altro ciclo for per iterare i valori i da 1 a i
per ( io = 1 ; io < M ; io ++ ) {
la mia chiave = arr2 [ io ] ;
J = io - 1 ;
Mentre ( J >= 0 && arr2 [ J ] < la mia chiave ) {
arr2 [ J + 1 ] = arr2 [ J ] ;
J = J - 1 ;
}
arr2 [ J + 1 ] = la mia chiave ;
}
}
int principale ( ) {
//Inserimento-Ordinamento con ordine decrescente
int mio_arr [ ] = { 5 , 4 , 60 , 9 } ; //inizializza un my_arr[] con quattro valori
int M = taglia di ( mio_arr ) / taglia di ( mio_arr [ 0 ] ) ;
insertorsort_descending ( mio_arr , M ) ;
printf ( 'Matrice ordinata in ordine decrescente: ' ) ;
per ( int io = 0 ; io < M ; io ++ )
printf ( '%D ' , mio_arr [ io ] ) ;
printf ( ' \N ' ) ;
//Inserimento-Ordinamento con ordine crescente
int N = taglia di ( mio_arr ) / taglia di ( mio_arr [ 0 ] ) ;
Insertionsort_ascending ( arr2 , N ) ;
printf ( 'Array ordinato in ordine crescente: ' ) ;
per ( int io = 0 ; io < N ; io ++ )
printf ( '%D ' , mio_arr [ io ] ) ;
printf ( ' \N ' ) ;
ritorno 0 ;
}
In questo codice, due metodi ordinamento_discendente() , E ordinamento_ascendente() prendere i valori dell'array di mio_arr[] . Il codice utilizza quindi a per ciclo per scorrere gli elementi dell'array.
Chiamiamo entrambe le funzioni nella funzione principale una volta che hanno ordinato gli array in ordine decrescente e crescente. Successivamente, i cicli for vengono utilizzati per stampare l'array ordinato.
Quando eseguiamo questo programma, l'output previsto viene posizionato di seguito:
Conclusione
L'ordinamento per inserzione è un modo rapido e semplice per ordinare un array in sequenza discendente o ascendente. Per piccoli set di dati, questa tecnica di ordinamento funziona bene. Come puoi vedere nella guida sopra, è semplice implementare un esempio di un programma C per comprendere facilmente l'ordinamento di inserimento in ordine decrescente e crescente.