Сортиране в C - Различни видове сортиране заедно с Пример

• Въведение в сортирането в С

Въведение в сортирането в С

В приложението разработчиците изпитват желание да сортират данните, за да позволят да се внесе определена функционалност. Има няколко подхода за сортиране на данните и те се броят подредени според номенклатурата. Сортирането може да бъде определен като метод за подреждане на данните по определен начин, който следва определен ред. Тук в този раздел ще научим за сортирането, използвайки езика за програмиране на С. Има няколко типа сортиране като сортиране на балон, сортиране на сливане, сортиране на селекция, сортиране на вмъкване и така нататък. Ще направим действително кодиране на методите за сортиране, които се използват много често в приложението. Кодовете ще са ви достъпни в текстов формат, така че можете да намерите лесно този код, докато изходът ще бъде показан на екрана, за да ви даде представа за действителния изход, който идва след стартиране на програмата.

Как се извършва сортирането в C?

• Сортирането може да се извърши по различни начини въз основа на алгоритъма за сортиране. В езика за програмиране на C имаме няколко подхода за сортиране на списъка. Терминът сортиране заявява подреждането на данни по определен начин, обикновено във възходящ ред. Въпреки че начинът за сортиране на данните е различен във всички алгоритми за сортиране, резултатът от всички тях е един и същ.
• Обикновено при сортирането програмата търси минималния брой и премества това число в началото на списъка и повтаря същите търсения. Отново след като се срещне другият малък брой, той се премества в следващото пространство в списъка веднага след първия индекс и този процес продължава да се повтаря, докато се получи списъка за сортиране. По този начин се извършва сортирането в езика за програмиране на С.
• При всички подходи за сортиране на списъка, масивът играе много жизненоважна роля в езика за програмиране на C. Във всеки алгоритъм масивът е използван за съхраняване на списъка на елементите, които трябва да бъдат сортирани. Например, в сортиране на балони, елементите се съхраняват в единичния масив и стойностите в масива са обработени, за да ги преобразуват в списък от сортирани данни.
• В сортирането на селекцията един и същ масив е третиран като два масива, където първият масив се счита за вакантен, за да каже сортирани стойности, докато вторият масив държи несортирания списък. За да служи на целта за сортиране на масива се използва много често, вместо да държи стойностите в отделни променливи. Сред всички алгоритми, бързото сортиране работи много бързо и оттук е наречено бързо сортиране. Това отнема много по-малко време в сравнение с другите алгоритми за сортиране.

Видове сортиране в С

1. Сортиране на балончета

• Сортирането на балончетата може да бъде дефинирано като алгоритъм за сортиране, който следва подхода за замяна на стойността в първия индекс с най-малката стойност в масива и я поддържа повтаряща, докато списъкът не бъде сортиран. Това е много прост начин за извършване на сортиране. По този начин за сортиране на масива стойността трябва да бъде присвоена на масива в началото, преди да започне сортирането.
• По-долу е програмата за сортиране на масива, използвайки сортиране на балончета, където стойностите са взети от потребителя. След като програмата се компилира и стартира, тя ще поиска от потребителя броя на елементите, които иска да сортира. След като номерът бъде предоставен, програмата ще поиска от потребителя да предостави стойности, еквивалентни на броя, който са предоставили. Стойностите ще бъдат съхранени в масива и ще бъдат обработени по-нататък, като се използват вложен за цикъл, заедно с вземане на решение, използвайки „ако“, за да се сортира масивът.
• Първата най-малка стойност, открита в масива, е преместена в първия индекс на масива и след това търсенето започва отново, за да намери другото най-малко число. След като бъде намерено следващото най-малко число, той замества стойността във втория индекс и процесът продължава да се повтаря, докато масивът не се състои от сортиран списък от стойности.

код

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

Потребителят е представил входа 5 3 60 14 1 2 645. Алгоритъмът е приложен върху масива, състоящ се от стойности по начина, по който е предоставен от потребителя и след обработката му полученият изход е 1 2 3 5 14 60 645,

изход:

2. Сортиране на селекцията

• Сортирането на селекция може да бъде дефинирано като друг алгоритъм за сортиране на списъка, в който масивът е разделен на два масива, където първият масив трябва да е празен, докато вторият масив се състои от несортиран списък от стойности. Програмата търси най-малките стойности във втория масив и когато стойността бъде намерена, тя е преместена в началото на първия масив, който е празен. Подходът се повтаря отново и следващите най-малки стойности ще бъдат преместени във втория индекс на първия масив. Процесите ще продължават да се повтарят, докато вторият масив не се изпразни.
• По-долу програмата е кодирането на алгоритъма за сортиране на селекцията. След като програмата работи успешно, тя ще поиска от потребителя да въведе броя на стойностите, които е готов да сортира. След като се получи броенето, програмата ще поиска от потребителя да въведе стойностите за масива, който трябва да бъде сортиран. След това стойността се обработва, като се използва вложен за цикъл, за да се сортират числата. Тук също е включена проверка на състоянието, за да се провери най-малкото число.
• Процесите ще се повтарят, докато първият списък не бъде пълен с сортирания списък. Междувременно програмите поддържат основния си фокус, за да проверят дали вторият масив има стойност и ако е установен, че е положителен, програмата отново стартира алгоритъма за сортиране. Въпреки че сортира списъка по лесен начин, това може да отнеме малко повече време в сравнение с другите алгоритми. Но до края резултатът, който ще генерира, ще бъде същият като останалите алгоритми за сортиране.

код
#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();
)

На въпрос за броя на елементите, които трябва да бъдат сортирани, потребителят е предоставил 6 в изхода по-долу. По-късно стойностите, които са били въведени, са 25 65 36 86 96 45. Тези стойности се съхраняват в масива, който се очаква да бъде раздвоен в два масива, където единият ще бъде празен за съхраняване на сортирания списък, а другият ще има несортиран списък, След обработката на входния резултат резултатът е 25 36 45 65 86 96. Тази загуба е сортирана чрез сортиране на селекцията. След като всички шест стойности са преместени в първия масив в подредената форма, вторият масив ще стане празен и алгоритъмът ще бъде прекратен.

изход:

3. Бързо сортиране

• Quicksort може да бъде определен като другият алгоритъм за сортиране на списъка, в който подходът е да се раздели масивът на стойности, по-големи от и по-малки от стойности, докато всички стойности, ако се разделят на индивиди, се формират. В този алгоритъм стойността на последния индекс на масива е избрана като въртяща се и всички стойности, по-малки от въртене, са преместени в масива, който се очаква да се появи вляво от стойността и елементите с по-висока стойност отколкото въртенето се премества в десния масив. Отново се избира един въртящ се от новообразувания масив, който е имал стойности по-малки от последната стойност на въртене. По същия начин стойностите, по-малки от новото въртене, ще бъдат преместени в масива, който ще бъде отляво, а стойностите повече от новото въртене ще бъдат изместени в десния масив.
• По-долу програмата е реализацията на quicksort, използвайки езика за програмиране на C. След като програмата се стартира, тя ще поиска от потребителя броя на елементите, които иска да сортира. Въз основа на броя, цикълът за цикъл ще повтори прогнозните времена, за да поеме данните от потребителя. Входът ще се обработва, като се използват условията if, заедно с цикъла for, за да се генерира сортиран списък. Масивът ще продължи да подрежда стойностите, използвайки въртящата се стойност, докато всички стойности не са проверени за най-малката стойност.
• Сортирането, извършено с помощта на този алгоритъм, е твърде бързо в сравнение с другите алгоритми за сортиране и затова той е кръстен бързо сортиране. Quicksort е единственият алгоритъм, който води до разделяне на масива, докато всички стойности не бъдат разделени на отделните масиви. След това те ще бъдат добавени или обобщени в един масив, който се счита за сортиран списък.

Код:

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

В изхода по-долу потребителят потвърди, че ще изпрати 6 стойности и да формира списък от сортирани данни. След предоставяне на броя, стойностите, предоставени от потребителя, са 56, 35, 24, 86, 98, 2. Към тези стойности е приложен quicksort и е генериран сортиран списък със стойност 2, 24, 35, 56, 86, 98.

изход:

4. Сливане на сортиране

• Сливане сортиране може да бъде дефинирано като друг алгоритъм за сортиране, който извършва сортирането чрез разделяне на масива до последно, когато той се превръща в индивидуална стойност и след това ги агрегира по начин, така че да може да се превърне в сортиран масив.
• Процесът отнема много много време в сравнение с другите конкурентни алгоритми, но се счита за доста ефективен в сравнение с други. Когато става въпрос за сортиране на голям списък, този алгоритъм работи много добре и следователно е предпочитан при разработването на приложението, което трябва да обработва големия списък.

Код:

#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);
)
Когато горният код работи, той първо моли потребителя да предостави броя на елементите, които иска да сортира. След като числото бъде представено, те ще трябва да предоставят стойностите на равен брой, които са предоставили първоначално. След като стойностите са изпратени, алгоритъмът ще задържи тези стойности в масива и ще го обработи, за да трансформира масива в подредения масив. След като масивът бъде сортиран във възходящ ред, изходът ще бъде показан на потребителя.

изход:

5. Хепсорт

• Сортирането на купчината може да бъде определено като алгоритъм за сортиране, който работи, като търси максималния елемент в списъка и го постави до последния. Алгоритъмът извършва действието рекурсивно, докато масивът се подреди във възходящия начин.
• Много е време да се вземе процесът да се избере максималната стойност и да се премести до последната и следователно той се счита за по-малко ефективен подход за сортиране, когато става въпрос за сортиране на големия списък. Въпреки това, той работи добре със списъка, който има ограничен брой стойности. По-долу е прилагането на този алгоритъм в езика за програмиране на C заедно с изхода.

Код:

#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;
)
)
)
Работата на този алгоритъм е същата като тази на другите алгоритми за сортиране, тъй като той също сортира списъка във възходящ ред. Когато гореизписаният код работи, потребителят трябва да представи броя на стойностите, които ще сортира. След като стойностите бъдат изпратени, кодът ще ги обработи, за да превърне масива в сортиран. Резултатът ще бъде показан в крайна сметка и може да се види, че стойностите, които са били подадени от потребителя, са сортирани във възходящ ред.

изход:

6. Сортиране на вмъкване

• Сортирането на вмъкване може да бъде дефинирано като алгоритъм за сортиране, който работи, като премества минималната стойност в началото на списъка една по една. Това е много по-малко ефективен алгоритъм за сортиране и не е подходящ за справяне с големия списък.
• Този подход на сортиране на алгоритъма работи много бавно и обикновено не се предпочита в никое от приложенията. Може да работи добре със списъка, който има доста малък брой елементи. За приложенията, които имат изискването да обработват няколко числа стойности, могат да използват този алгоритъм.

Код:

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

Когато програмата работи, потребителят ще трябва да въведе броя на стойностите, които трябва да сортира. След това въведените от потребителя стойности ще се съхраняват в масива. След това те ще преминат в обработка и с използването на за контур и проверка на състоянието, минималната стойност ще бъде преместена в началото при всяка рекурсия и ще завърши чрез генериране на сортиран масив. Стойностите ще бъдат показани на потребителя в края на програмата.

Резултат:

заключение

Алгоритъмът за сортиране се използва за генериране на сортиран списък, който е нормален списък, където всички стойности са сортирани по определен начин. Списъкът е използван много често в действителното приложение, за да донесе някои функционалности. В тази статия сме обхванали сортиране на балон, сортиране на селекция и quicksort, докато има няколко други алгоритми като сортиране на сливане, също са там, които могат да се използват за генериране на сортиран списък. Сред всички алгоритми за сортиране, quicksort работи много бързо и помага за сортирането на списъка много бързо. Програмите, написани тук, са основно за изпълнение на тези алгоритми за сортиране, използвайки езика за програмиране на С. Ако желаете да приложите същото в други езици на програмиране, можете да използвате същата логика и единственото нещо, което може да варира, може да бъде синтаксисът и ключовите думи.

Препоръчителен член

Това е ръководство за сортиране в C. Тук обсъждаме въведение в сортирането в C и различни видове сортиране заедно с примерен код. Можете да разгледате и другите ни предложени статии, за да научите повече -

1. Модели в C програмирането
2. Палиндром в програма C
3. Обединяване Сортиране в Java
4. Въведение в сортирането в R
5. Въведение в сортирането в C ++
6. Преглед на сортирането в PHP
7. Сортиране на купи в Python
8. Функция за сортиране в Python с примери