Tri en C - Différents types de tri avec exemple

• Introduction au tri en C

Introduction au tri en C

Dans l'application, les développeurs ressentent l'envie de trier les données afin de laisser apporter des fonctionnalités particulières. Il existe plusieurs approches pour trier les données et elles sont comptabilisées dans le tri selon la nomenclature. Le tri peut être défini comme la méthode d'organisation des données d'une manière particulière qui suit un certain ordre. Ici, dans cette section, nous allons découvrir le tri à l'aide du langage de programmation C. Il existe plusieurs types de tri comme le tri à bulles, le tri par fusion, le tri par sélection, le tri par insertion, etc. Nous effectuerons un codage réel pour les méthodes de tri utilisées très souvent dans l'application. Les codes seront à votre disposition dans un format textuel afin que vous puissiez trouver facile à utiliser ce code tandis que la sortie sera affichée dans la capture d'écran pour vous donner un aperçu de la sortie réelle qui vient après l'exécution du programme.

Comment s'effectue le tri en C?

• Le tri peut être effectué de différentes manières en fonction de l'algorithme de tri. Dans le langage de programmation C, nous avons plusieurs approches pour trier la liste. Le terme de tri indique l'organisation des données d'une manière particulière, généralement par ordre croissant. Bien que la façon de trier les données soit différente dans tous les algorithmes de tri, le résultat de chacun d'eux est le même.
• Habituellement, lors du tri, le programme recherche le nombre minimum et déplace ce nombre au début de la liste et répète les mêmes recherches. Une fois de plus, l'autre petit nombre est rencontré, il est déplacé vers l'espace suivant de la liste juste après le premier index et ce processus continue de se répéter jusqu'à ce que la liste de tri soit obtenue. C'est ainsi que le tri est effectué dans le langage de programmation C.
• Dans toutes les approches pour trier la liste, le tableau joue un rôle très vital dans le langage de programmation C. Dans chaque algorithme, le tableau a été utilisé pour stocker la liste des éléments à trier. Par exemple, dans le tri à bulles, les éléments sont stockés dans le tableau unique et les valeurs du tableau ont été traitées pour les convertir en une liste de données triées.
• Dans le tri par sélection, le même tableau a été traité comme deux tableaux où le premier tableau est considéré comme vacant afin d'indiquer les valeurs triées tandis que le second tableau contient la liste non triée. Pour servir à trier le tableau est utilisé très souvent au lieu de conserver les valeurs dans des variables individuelles. Parmi tous les algorithmes, le tri rapide fonctionne très rapidement et est donc nommé tri rapide. Cela prend beaucoup moins de temps que les autres algorithmes de tri.

Types de tri en C

1. Tri des bulles

• Le tri à bulles peut être défini comme l'algorithme de tri qui suit l'approche consistant à remplacer la valeur du premier index par la plus petite valeur du tableau et à la répéter jusqu'à ce que la liste soit triée. C'est un moyen très simple d'effectuer le tri. De cette façon, pour trier le tableau, la valeur doit être affectée au tableau au début avant de commencer le tri.
• Ci-dessous se trouve le programme pour trier le tableau en utilisant le tri à bulles où les valeurs ont été prises par l'utilisateur. Une fois le programme compilé et exécuté, il demandera à l'utilisateur le nombre d'éléments qu'il souhaite trier. Une fois le nombre fourni, le programme demandera à l'utilisateur de fournir des valeurs équivalentes au nombre qu'il a fourni. Les valeurs seront stockées dans le tableau et seront traitées ultérieurement en utilisant la boucle imbriquée pour ainsi que la prise de décision en utilisant «si» afin de trier le tableau.
• La première plus petite valeur trouvée dans le tableau a été déplacée vers le premier index du tableau, puis la recherche recommence pour trouver l'autre plus petit nombre. Une fois le plus petit nombre suivant trouvé, il remplace la valeur dans le deuxième index et le processus continue de se répéter jusqu'à ce que le tableau se compose d'une liste triée de valeurs.

Code

#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'utilisateur a soumis l'entrée 5 3 60 14 1 2 645. L'algorithme a été appliqué sur le tableau composé de valeurs de la manière dont il est fourni par l'utilisateur et après le traitement, la sortie que nous avons reçue est 1 2 3 5 14 60 645 .

Production:

2. Tri de sélection

• Le tri par sélection peut être défini comme un autre algorithme pour trier la liste dans laquelle le tableau est bifurqué en deux tableaux où le premier tableau est censé être vide tandis que le second tableau se compose de la liste de valeurs non triées. Le programme recherche les plus petites valeurs dans le deuxième tableau et lorsque la valeur est trouvée, elle a été déplacée au début du premier tableau qui était vide. L'approche est répétée à nouveau et les valeurs les plus petites suivantes seront décalées vers le deuxième index du premier tableau. Les processus continueront de se répéter jusqu'à ce que le deuxième tableau devienne vide.
• Le programme ci-dessous est l'implémentation de codage de l'algorithme de tri de sélection. Une fois le programme exécuté avec succès, il demandera à l'utilisateur de saisir le nombre de valeurs qu'il souhaite trier. Une fois le décompte obtenu, le programme demandera à l'utilisateur de saisir les valeurs du tableau à trier. La valeur est ensuite traitée à l'aide de la boucle imbriquée pour trier les nombres. La vérification des conditions if a également été impliquée ici pour vérifier le plus petit nombre.
• Les processus seront répétés jusqu'à ce que la première liste soit pleine de la liste triée. Pendant ce temps, les programmes conservent leur objectif principal pour vérifier si le second tableau a une valeur et s'il est trouvé positif, le programme exécute à nouveau l'algorithme de tri. Bien qu'il trie la liste de manière simple, cela peut prendre un peu plus de temps par rapport aux autres algorithmes. Mais à la fin, le résultat qu'il générera sera le même que les autres algorithmes de tri.

Code
#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();
)

En demandant le nombre d'éléments à trier, l'utilisateur a fourni 6 dans la sortie ci-dessous. Plus tard, les valeurs qui ont été entrées sont 25 65 36 86 96 45. Ces valeurs sont stockées dans le tableau qui devrait être bifurqué en deux tableaux où l'un sera vide pour stocker la liste triée et l'autre aura la liste non triée . Après traitement de l'entrée, le résultat était 25 36 45 65 86 96. Cette perte a été triée à l'aide du tri par sélection. Une fois que toutes les six valeurs ont été déplacées vers le premier tableau sous la forme triée, le deuxième tableau devient vide et l'algorithme se termine.

Production:

3. Tri rapide

• Quicksort peut être défini comme l'autre algorithme de tri de la liste dans laquelle l'approche consiste à diviser le tableau en termes de valeurs supérieures et inférieures à jusqu'à ce que les valeurs entières soient divisées en formulaires individuels. Dans cet algorithme, la valeur du dernier index du tableau a été sélectionnée comme pivot et toutes les valeurs plus petites que pivot ont été déplacées vers le tableau qui devrait se produire à gauche de la valeur et les éléments ayant une valeur plus élevée que le pivot sont déplacés vers le bon tableau. Encore un pivot est sélectionné dans le tableau nouvellement formé qui avait des valeurs inférieures à la dernière valeur de pivot. De même, les valeurs plus petites que le nouveau pivot seront déplacées vers le tableau qui restera et les valeurs plus que le nouveau pivot seront décalées dans le tableau de droite.
• Le programme ci-dessous est l'implémentation de tri rapide utilisant le langage de programmation C. Une fois le programme exécuté, il demandera à l'utilisateur le nombre d'éléments qu'il souhaite trier. Sur la base du comptage, la boucle for itérera les temps estimés pour prendre l'entrée de l'utilisateur. L'entrée sera traitée en utilisant les conditions if avec la boucle for afin de générer une liste triée. Le tableau continuera d'organiser les valeurs à l'aide de la valeur pivot jusqu'à ce que toutes les valeurs aient été vérifiées pour la plus petite valeur.
• Le tri effectué à l'aide de cet algorithme est beaucoup trop rapide par rapport aux autres algorithmes de tri et c'est pourquoi il a été nommé tri rapide. Quicksort est le seul algorithme qui conduit à diviser le tableau jusqu'à ce que toutes les valeurs soient séparées dans les tableaux individuels. Ils seront ensuite ajoutés ou agrégés dans un seul tableau qui est considéré comme la liste triée.

Code:

#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);
)
)

Dans la sortie ci-dessous, l'utilisateur a confirmé qu'il soumettra 6 valeurs et formera une liste de données triées. Après avoir fourni le nombre, les valeurs fournies par l'utilisateur sont 56, 35, 24, 86, 98, 2. Le tri rapide a été appliqué à ces valeurs et la liste triée a été générée avec la valeur 2, 24, 35, 56, 86, 98.

Production:

4. Tri par fusion

• Le tri par fusion peut être défini comme un autre algorithme de tri qui effectue le tri en séparant le tableau jusqu'au dernier lorsqu'il se transforme en valeur individuelle, puis en les agrégeant de manière à ce qu'il puisse se transformer en tableau trié.
• Le processus prend un peu de temps par rapport aux autres algorithmes concurrents, mais il est considéré comme assez efficace par rapport aux autres. Lorsqu'il s'agit de trier une grande liste, cet algorithme fonctionne très bien et est donc préférable pour développer l'application qui doit traiter la grande liste.

Code:

#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);
)
Lorsque le code ci-dessus s'exécute, il demande d'abord à l'utilisateur de fournir le nombre d'éléments qu'il souhaite trier. Une fois le numéro soumis, ils devront fournir les valeurs de nombre égal qu'ils ont fournies initialement. Une fois les valeurs soumises, l'algorithme conservera ces valeurs dans le tableau et les traitera pour transformer le tableau en tableau trié. Une fois le tableau trié par ordre croissant, la sortie sera affichée pour l'utilisateur.

Production:

5. Heapsort

• Le tri en tas peut être défini comme l'algorithme de tri qui fonctionne en recherchant l'élément maximum dans la liste et en le plaçant au dernier. L'algorithme exécute l'action de manière récursive jusqu'à ce que le tableau soit trié dans l'ordre croissant.
• Il est très long de prendre le processus pour choisir la valeur maximale et la déplacer vers la dernière et, par conséquent, elle est considérée comme une approche de tri moins efficace lorsqu'il s'agit de trier la grande liste. Cependant, cela fonctionne très bien avec la liste qui a un nombre limité de valeurs. Voici l'implémentation de cet algorithme dans le langage de programmation C avec la sortie.

Code:

#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;
)
)
)
Le fonctionnement de cet algorithme est le même que celui des autres algorithmes de tri car il trie également la liste par ordre croissant. Lorsque le code écrit ci-dessus s'exécute, l'utilisateur doit soumettre le nombre de valeurs qu'il triera. Une fois les valeurs soumises, le code les traitera pour transformer le tableau en tableau trié. La sortie sera finalement affichée et on peut observer que les valeurs soumises par l'utilisateur ont été triées par ordre croissant.

Production:

6. Tri par insertion

• Le tri par insertion peut être défini comme l'algorithme de tri qui fonctionne en déplaçant la valeur minimale au début de la liste une par une. Il s'agit d'un algorithme de tri très moins efficace qui ne convient pas pour traiter la grande liste.
• Cette approche de tri de l'algorithme fonctionne très lentement et n'est généralement préférée dans aucune des applications. Cela peut bien fonctionner avec la liste qui contient assez peu d'éléments. Pour les applications, qui ont besoin de traiter quelques nombres de valeurs peuvent tirer parti de cet algorithme.

Code:

#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;
)

Lors de l'exécution du programme, l'utilisateur devra saisir le nombre de valeurs dont il a besoin pour trier. Par la suite, les valeurs entrées par l'utilisateur seront stockées dans le tableau. Ils seront ensuite soumis au traitement et en utilisant la vérification de boucle et de condition, la valeur minimale sera déplacée au début de chaque récursivité et finira par générer un tableau trié. Les valeurs seront affichées à l'utilisateur à la fin du programme.

Production :

Conclusion

L'algorithme de tri est utilisé pour générer une liste triée qui est une liste normale où toutes les valeurs sont triées d'une manière particulière. La liste a été utilisée très souvent dans l'application réelle pour apporter quelques fonctionnalités. Dans cet article, nous avons couvert le tri à bulles, le tri par sélection et le tri rapide, tandis qu'il existe plusieurs autres algorithmes comme le tri par fusion qui peuvent également être utilisés pour générer une liste triée. Parmi tous les algorithmes de tri, quicksort fonctionne très rapidement et permet de trier la liste très rapidement. Les programmes écrits ici visent essentiellement à implémenter ces algorithmes de tri à l'aide du langage de programmation C. Si vous êtes prêt à implémenter le même dans d'autres langages de programmation, vous pouvez utiliser la même logique et la seule chose qui peut varier peut être la syntaxe et les mots-clés.

Article recommandé

Cela a été un guide pour le tri en C. Ici, nous discutons d'une introduction au tri en C et de différents types de tri avec un exemple de code. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -

1. Modèles en programmation C
2. Palindrome en programme C
3. Fusionner le tri en Java
4. Introduction au tri dans R
5. Introduction au tri en C ++
6. Présentation du tri en PHP
7. Tri de tas en Python
8. Fonction de tri en Python avec des exemples