Introduzione all'ordinamento in C

Nell'applicazione, gli sviluppatori sentono il bisogno di ordinare i dati per consentire di portare funzionalità particolari. Esistono diversi approcci per ordinare i dati e questi vengono conteggiati nell'ordinamento secondo la nomenclatura. L'ordinamento può essere definito come il metodo di organizzazione dei dati in un modo particolare che segue un certo ordine. Qui in questa sezione impareremo l'ordinamento usando il linguaggio di programmazione C. Esistono diversi tipi di ordinamento come ordinamento a bolle, ordinamento unione, ordinamento selezione, ordinamento inserzione e così via. Eseguiremo la codifica effettiva per i metodi di ordinamento utilizzati molto spesso nell'applicazione. I codici saranno disponibili in un formato testuale in modo che tu possa trovare facilmente usare quel codice mentre l'output verrà visualizzato nello screenshot per darti un'idea dell'output effettivo che viene dopo l'esecuzione del programma.

Come viene eseguito l'ordinamento in C?

  • L'ordinamento può essere eseguito in vari modi in base all'algoritmo di ordinamento. Nel linguaggio di programmazione C abbiamo diversi approcci per ordinare l'elenco. Il termine ordinamento indica la disposizione dei dati in un modo particolare di solito in ordine crescente. Sebbene il modo di ordinare i dati sia diverso in tutti gli algoritmi di ordinamento, il risultato di tutti loro è lo stesso.
  • Di solito, nell'ordinamento, il programma cerca il numero minimo e lo sposta all'inizio della lista e ripete le stesse ricerche. Ancora una volta, quando viene rilevato l'altro piccolo numero, viene spostato nello spazio successivo nell'elenco subito dopo il primo indice e questo processo continua a ripetersi fino a quando non viene ottenuto l'elenco di ordinamento. Questo è il modo in cui l'ordinamento viene eseguito nel linguaggio di programmazione C.
  • In tutti gli approcci per ordinare l'elenco, l'array svolge un ruolo molto vitale nel linguaggio di programmazione C. In ogni algoritmo, l'array è stato utilizzato per memorizzare l'elenco degli elementi che devono essere ordinati. Ad esempio, nell'ordinamento a bolle, gli elementi sono memorizzati nella singola matrice e i valori nella matrice sono stati elaborati per convertirli in un elenco di dati ordinati.
  • Nell'ordinamento di selezione, lo stesso array è stato trattato come due array in cui il primo array è considerato vacante per comunicare i valori ordinati mentre il secondo array contiene l'elenco non ordinato. Per servire allo scopo di ordinare l'array viene usato molto spesso invece di contenere i valori nelle singole variabili. Tra tutti gli algoritmi, l'ordinamento rapido funziona in modo molto rapido e quindi denominato ordinamento rapido. Richiede molto meno tempo rispetto agli altri algoritmi di ordinamento.

Tipi di ordinamento in C

1. Bubble Sort

  • L'ordinamento a bolle può essere definito come l'algoritmo di ordinamento che segue l'approccio della sostituzione del valore nel primo indice con il valore più piccolo nell'array e di mantenerlo ripetuto fino a quando l'elenco non viene ordinato. È un modo molto semplice per eseguire l'ordinamento. In questo modo per ordinare l'array, il valore deve essere assegnato all'inizio all'array prima di iniziare l'ordinamento.
  • Di seguito è riportato il programma per ordinare l'array usando l'ordinamento a bolle in cui i valori sono stati presi dall'utente. Una volta compilato ed eseguito, il programma chiederà all'utente il numero di elementi che desidera ordinare. Una volta fornito il numero, il programma chiederà all'utente di fornire valori equivalenti al conteggio che hanno fornito. I valori verranno memorizzati nell'array e verranno ulteriormente elaborati utilizzando il ciclo nidificato insieme al processo decisionale utilizzando "if" per ordinare l'array.
  • Il primo valore più piccolo trovato nell'array è stato spostato nel primo indice dell'array e quindi la ricerca ricomincia da capo per trovare l'altro numero più piccolo. Una volta trovato il numero più piccolo successivo, sostituisce il valore nel secondo indice e il processo continua a ripetersi fino a quando l'array è costituito da un elenco ordinato di valori.

Codice

#include
int main()
(
int total_count, counter, counter1, swap_var;
int array(20);
printf("How many number you want to input?\n");
scanf("%d", &total_count);
printf("Please enter %d integers that has to be sorted\n", total_count);
for (counter = 0; counter < total_count; counter++)
scanf("%d", &array(counter));
for (counter = 0 ; counter < total_count - 1; counter++)
(
for (counter1 = 0 ; counter1 < total_count - counter - 1; counter1++)
(
if (array(counter1) > array(counter1+1)) /* For decreasing order use < */
(
swap_var = array(counter1);
array(counter1) = array(counter1+1);
array(counter1+1) = swap_var;
)
)
)
printf("Below is the list of elements sorted in ascending order:\n");
for (counter = 0; counter < total_count; counter++)
printf("%d\n", array(counter));
return 0;
)

L'utente ha inviato l'input 5 3 60 14 1 2 645. L'algoritmo è stato applicato sull'array costituito da valori nel modo in cui è fornito dall'utente e dopo averlo elaborato l'output che abbiamo ricevuto è 1 2 3 5 14 60 645 .

Produzione:

2. Selezione ordinamento

  • L'ordinamento di selezione può essere definito come un altro algoritmo per ordinare l'elenco in cui l'array è suddiviso in due array in cui il primo array dovrebbe essere vuoto mentre il secondo array è costituito dall'elenco di valori non ordinato. Il programma cerca i valori più piccoli nel secondo array e quando il valore viene trovato, è stato spostato all'inizio del primo array che era vuoto. L'approccio viene ripetuto di nuovo e i valori più piccoli successivi verranno spostati sul secondo indice del primo array. I processi continueranno a ripetersi fino a quando il secondo array diventa vuoto.
  • Il seguente programma è l'implementazione di codifica dell'algoritmo di ordinamento della selezione. Una volta eseguito correttamente, il programma richiederà all'utente di inserire il conteggio dei valori che desidera ordinare. Una volta ottenuto il conteggio, il programma chiederà all'utente di inserire i valori per l'array che deve essere ordinato. Il valore viene quindi elaborato utilizzando il ciclo nidificato per ordinare i numeri. Anche il controllo della condizione if è stato coinvolto qui per verificare il numero più piccolo.
  • I processi verranno ripetuti fino a quando il primo elenco non sarà pieno dell'elenco ordinato. Nel frattempo, i programmi mantengono il focus primario per verificare se il secondo array ha valore e se viene trovato positivo, il programma esegue nuovamente l'algoritmo di ordinamento. Anche se ordina l'elenco in modo semplice, potrebbe richiedere un po 'più di tempo rispetto agli altri algoritmi. Ma alla fine, il risultato che genererà sarà lo stesso degli altri algoritmi di ordinamento.

Codice
#include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
)

Alla richiesta del conteggio degli elementi che devono essere ordinati, l'utente ha fornito 6 nell'output di seguito. Successivamente i valori che sono stati immessi sono 25 65 36 86 96 45. Questi valori sono memorizzati nell'array che dovrebbe essere biforcato in due array in cui uno sarà vuoto per memorizzare l'elenco ordinato e l'altro avrà l'elenco non ordinato . Dopo aver elaborato l'input, il risultato è stato 25 36 45 65 86 96. Questa perdita è stata ordinata usando l'ordinamento di selezione. Una volta che tutti e sei i valori sono stati spostati nel primo array nella forma ordinata, il secondo array diventerà vuoto e l'algoritmo verrà terminato.

Produzione:

3. Ordinamento rapido

  • Quicksort può essere definito come l'altro algoritmo per ordinare l'elenco in cui l'approccio è quello di dividere l'array in termini di maggiore o minore di valori fino a quando gli interi valori se divisi in singole forme. In questo algoritmo, il valore dell'ultimo indice dell'array è stato selezionato come pivot e tutti i valori inferiori a pivot sono stati spostati nell'array che si prevede si verifichi a sinistra del valore e gli elementi che hanno un valore più alto che il perno viene spostato sull'array giusto. Ancora una volta un pivot viene selezionato dall'array appena formato che aveva i valori inferiori all'ultimo valore pivot. Allo stesso modo, i valori più piccoli del nuovo pivot verranno spostati nell'array che verrà lasciato e i valori più del nuovo pivot verranno spostati nell'array giusto.
  • Il seguente programma è l'implementazione di quicksort usando il linguaggio di programmazione C. Una volta eseguito il programma, chiederà all'utente il numero di elementi che desidera ordinare. Sulla base del conteggio, il ciclo for ripeterà i tempi stimati per ricevere l'input dall'utente. L'input verrà elaborato utilizzando le condizioni if ​​insieme al ciclo for per generare un elenco ordinato. L'array continuerà a disporre i valori utilizzando il valore pivot fino a quando tutti i valori non sono stati controllati per il valore più piccolo.
  • L'ordinamento fatto usando questo algoritmo è molto più veloce rispetto agli altri algoritmi di ordinamento ed è per questo che è stato nominato ordinamento rapido. Quicksort è l'unico algoritmo che porta alla divisione dell'array fino a quando tutti i valori non vengono separati nei singoli array. Verranno quindi aggiunti o aggregati in un singolo array che viene considerato come l'elenco ordinato.

Codice:

#include
void quicksort_method (int (), int, int);
int main()
(
int element_list(50), count, counter;
printf("Please enter the total count of the elements that you want to sort: ");
scanf("%d", &count);
printf("Please input the elements that has to be sorted:\n");
for (counter = 0; counter < count; counter++)
(
scanf("%d", &element_list(counter));
)
quicksort_method(element_list, 0, count - 1);
printf("Output generated after using quick sort\n");
for (counter = 0; counter < count; counter++)
(
printf("%d ", element_list(counter));
)
printf("\n");
return 0;
)
void quicksort_method(int element_list(), int low, int high)
(
int pivot, value1, value2, temp;
if (low < high)
(
pivot = low;
value1 = low;
value2 = high;
while (value1 < value2)
(
while (element_list(value1) <= element_list(pivot) && value1 <= high)
(
value1++;
)
while (element_list(value2) > element_list(pivot) && value2 >= low)
(
value2--;
)
if (value1 < value2)
(
temp = element_list(value1);
element_list(value1) = element_list(value2);
element_list(value2) = temp;
)
)
temp = element_list(value2);
element_list(value2) = element_list(pivot);
element_list(pivot) = temp;
quicksort_method(element_list, low, value2 - 1);
quicksort_method(element_list, value2 + 1, high);
)
)

Nell'output di seguito, l'utente ha confermato che presenterà 6 valori e formerà un elenco di dati ordinati. Dopo aver fornito il conteggio, i valori forniti dall'utente sono 56, 35, 24, 86, 98, 2. Il quicksort è stato applicato a questi valori e la lista ordinata è stata generata con il valore 2, 24, 35, 56, 86, 98.

Produzione:

4. Unisci ordinamento

  • Unire l'ordinamento può essere definito come un altro algoritmo di ordinamento che esegue l'ordinamento separando l'array fino all'ultimo quando si trasforma in un singolo valore e quindi aggregandoli in modo da poterlo trasformare in un array ordinato.
  • Il processo richiede un po 'più di tempo rispetto agli altri algoritmi concorrenti ma è considerato piuttosto efficiente rispetto ad altri. Quando si tratta di ordinare un elenco di grandi dimensioni, questo algoritmo funziona molto bene e quindi preferisce sviluppare l'applicazione che deve elaborare l'elenco di grandi dimensioni.

Codice:

#include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
)
Quando viene eseguito il codice precedente, viene innanzitutto chiesto all'utente di fornire il numero di elementi che desidera ordinare. Una volta che il numero è stato inviato, dovranno fornire i valori di conteggio uguale forniti inizialmente. Una volta che i valori sono stati inviati, l'algoritmo manterrà tali valori nell'array e lo elaborerà per trasformare l'array nell'array ordinato. Dopo che l'array è stato ordinato in ordine crescente, l'output verrà visualizzato all'utente.

Produzione:

5. Heapsort

  • L'ordinamento heap può essere definito come l'algoritmo di ordinamento che funziona cercando l'elemento massimo nell'elenco e posizionandolo fino all'ultimo. L'algoritmo esegue l'azione in modo ricorsivo fino a quando l'array non viene ordinato in modo crescente.
  • È molto tempo impiegando il processo a scegliere il valore massimo e spostarlo all'ultimo, quindi è considerato un approccio di ordinamento meno efficiente quando si tratta di ordinare l'elenco di grandi dimensioni. Tuttavia, funziona bene con l'elenco che ha un numero limitato di valori. Di seguito è l'implementazione di questo algoritmo nel linguaggio di programmazione C insieme all'output.

Codice:

#include
void form(int ());
void set_down(int (), int);
int main()
(
int val(100), chk, counter, end, temp_val;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter=1;counter<=chk;counter++)
scanf("%d", &val(counter));
val(0)=chk;
form(val);
while(val(0) > 1)
(
end=val(0);
temp_val=val(1);
val(1)=val(end);
val(end)=temp_val;
val(0)--;
set_down(val, 1);
)
printf("\n Output generated after using heap sort \n");
for(counter=1;counter<=chk;counter++)
printf("%d ", val(counter));
)
void form(int val())
(
int counter, chk;
chk=val(0);
for(counter=chk/2;counter>=1;counter--)
set_down(val, counter);
)
void set_down(int val(), int counter)
(
int counter2, temp_val, chk, flag=1;
chk=val(0);
while(2*counter<=chk && flag==1)
(
counter2=2*counter;
if(counter2+1 val(counter2))
counter2=counter2+1;
if(val(counter) > val(counter2))
flag=0;
else
(
temp_val=val(counter);
val(counter)=val(counter2);
val(counter2)=temp_val;
counter=counter2;
)
)
)
Il funzionamento di questo algoritmo è lo stesso di quello di altri algoritmi di ordinamento in quanto ordina l'elenco in ordine crescente. Quando viene eseguito il codice sopra scritto, l'utente deve inviare il conteggio dei valori che verranno ordinati. Una volta inviati i valori, il codice li elaborerà per trasformare l'array in quello ordinato. L'output verrà mostrato alla fine e si può osservare che i valori che sono stati inviati dall'utente sono ordinati in ordine crescente.

Produzione:

6. Inserimento ordinamento

  • L'ordinamento per inserzione può essere definito come l'algoritmo di ordinamento che funziona spostando il valore minimo all'inizio dell'elenco uno alla volta. Questo è un algoritmo di ordinamento molto meno efficiente e non trovato adatto per gestire l'elenco di grandi dimensioni.
  • Questo approccio all'ordinamento dell'algoritmo funziona molto lentamente e di solito non è preferito in nessuna delle applicazioni. Può funzionare bene con l'elenco che contiene abbastanza pochi elementi. Per le applicazioni che hanno il requisito di elaborare alcuni numeri di valori possono sfruttare questo algoritmo.

Codice:

#include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
) #include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
) #include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
)

Quando il programma viene eseguito, l'utente dovrà inserire il numero di valori che deve ordinare. Successivamente, i valori immessi dall'utente verranno memorizzati nell'array. Andranno quindi in fase di elaborazione e mediante l'uso di per il controllo di loop e condizione, il valore minimo verrà spostato all'inizio in ogni ricorsione e alla fine generando un array ordinato. I valori verranno visualizzati all'utente alla fine del programma.

Produzione :

Conclusione

L'algoritmo di ordinamento viene utilizzato per generare un elenco ordinato che è un elenco normale in cui tutti i valori sono ordinati in un modo particolare. L'elenco è stato usato molto spesso nell'applicazione reale per apportare alcune funzionalità. In questo articolo abbiamo trattato dell'ordinamento a bolle, dell'ordinamento per selezione e dell'ordinamento rapido mentre ci sono molti altri algoritmi come l'ordinamento per fusione che può essere sfruttato per generare un elenco ordinato. Tra tutti gli algoritmi di ordinamento, quicksort funziona molto velocemente e aiuta a ordinare l'elenco molto rapidamente. I programmi scritti qui sono fondamentalmente per implementare questi algoritmi di ordinamento usando il linguaggio di programmazione C. Se si desidera implementare lo stesso in altri linguaggi di programmazione, è possibile utilizzare la stessa logica e l'unica cosa che può variare può essere la sintassi e le parole chiave.

Articolo raccomandato

Questa è stata una guida per l'ordinamento in C. Qui discutiamo un'introduzione nell'ordinamento in C e diversi tipi di ordinamento insieme al codice di esempio. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -

  1. Pattern nella programmazione C.
  2. Programma Palindrome in C.
  3. Unisci ordinamento in Java
  4. Introduzione all'ordinamento in R
  5. Introduzione all'ordinamento in C ++
  6. Panoramica dell'ordinamento in PHP
  7. Ordinamento dell'heap in Python
  8. Funzione di ordinamento in Python con esempi

Categoria:

Sviluppo software