Разврставање у Ц - Различите врсте сортирања заједно са примером

• Увод у сортирање у Ц

Увод у сортирање у Ц

У апликацији, програмери осећају потребу за сортирањем података како би донијели одређену функционалност. Постоји неколико приступа за сортирање података и они се рачунају под редом према номенклатури. Сортирање се може дефинисати као метода аранжирања података на одређени начин који слиједи неки редослијед. Овде у овом одељку сазнаћемо о сортирању помоћу програмског језика Ц. Постоји неколико врста сортирања као што су врста мехурића, врста спајања, сортирање селекције, врста уметања и тако даље. Урадит ћемо стварно кодирање метода сортирања који се веома често користе у апликацији. Кодови ће вам бити доступни у текстуалном формату тако да ћете лако пронаћи тај код док ће се излаз приказати на слици како бисте добили увид у стварни излаз који долази након покретања програма.

Како се сортира у Ц?

• Сортирање се може извести на различите начине на основу алгоритма сортирања. У програмском језику Ц имамо неколико приступа за сортирање листе. Појам сортирање наводи сређивање података на одређени начин, обично узлазним редоследом. Иако је начин сортирања података различит у свим алгоритмима за сортирање, исход свих њих је исти.
• Обично, приликом сортирања, програм тражи најмањи број и помера тај број на почетак листе и понавља исте претраге. Поновно када се сусретне други мали број, он се премешта на следеће место на листи одмах после првог индекса и овај поступак се наставља док се не добије листа сортирања. На тај се начин сортирање врши у програмском језику Ц.
• У свим приступима сортирању листе, низ игра веома виталну улогу у програмском језику Ц. У сваком алгоритму је низ кориштен за чување листе елемената које је потребно сортирати. На примјер, у врстама мјехурића елементи су похрањени у појединачном пољу, а вриједности у пољу су обрађене како би их претворили у листу сортираних података.
• У селекцијској сорти, исти низ се третира као два низа у којима се сматра да је први низ празан да би могао да каже сортиране вредности, док други низ држи листу одјављених. Да би се искористила сврха сортирања низа користи се врло често уместо да вредности држе у појединим променљивим. Међу свим алгоритмима, брзо сортирање делује врло брзо и отуда је названо брзо сортирање. Потребно је много мање времена у поређењу с другим алгоритмима за сортирање.

Врсте сортирања у Ц

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. Брзо сортирање

• Куицксорт се може дефинисати као други алгоритам за разврставање листе у којој је приступ поделити низ на веће и мање вредности, све док се целокупне вредности не поделе на појединачне форме. У овом алгоритму, вредност последњег индекса низа је изабрана као стожер и све вредности мање од стопе премештене су на матрицу за коју се очекује да ће се појавити на левој страни вредности и елементе који имају већу вредност него стожер се помера у десни низ. Поново је један окрет изабран из новоформираног низа који је имао вредности мање од последње вредности окрета. Слично томе, вредности мање од новог окретног помераће се у низ који ће бити леви, а вредности више од новог стожера помераће се у десни низ.
• Програм у наставку је куицксорт имплементација користећи програмски језик Ц. Једном када се програм покрене, од корисника ће тражити број елемената које жели да сортира. На основу броја, петља фор ће поновити процијењена времена за унос корисника. Улаз ће бити обрађен користећи иф ако заједно са фор за петљу како би се генерирала сортирана листа. Низ ће настављати с уређивањем вриједности користећи вриједност окрета, све док све вриједности нису провјерене за најмању вриједност.
• Сортирање које се врши овим алгоритмом је сувише брзо у поређењу с другим алгоритмима за сортирање и зато је добило назив брза врста. Куицксорт је једини алгоритам који доводи до дељења низа све док се све вредности не раздвоје на појединачне низове. Затим ће бити додани или обједињени у једном низу који се сматра сортираним списком.

Шифра:

#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. На ове вредности је примењен брзи скуп и генерисана је сортирана листа која има вредност 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. Хеапсорт

• Поредак хрпе може се дефинисати као алгоритам сортирања који ради претрагом максималног елемента на листи и постављањем последњег. Алгоритам изводи радњу рекурзивно док се низ не разврста на узлазни начин.
• Скоро је потребно да се поступак одабере максимална вредност и да се премести на последњу, па се стога сматра мање ефикасним приступом разврставању када је у питању сортирање велике листе. Међутим, он одлично функционира са списком који има ограничен број вредности. Испод је имплементација овог алгоритма у програмском језику Ц заједно са излазом.

Шифра:

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

Када се програм покрене, корисник ће морати унијети број вриједности које ће му требати сортирати. Након тога, вриједности које корисник унесе бит ће похрањене у низ. Затим ће прећи у обраду и коришћењем за петљу и проверу стања, минимална вредност биће померена на почетак у свакој рекурзији и на крају генерисањем сортиране матрице. Вриједности ће бити приказане кориснику на крају програма.

Излаз:

Закључак

Алгоритам сортирања користи се за генерисање сортиране листе која је нормална листа на којој су све вриједности сортиране на одређени начин. Листа се често користи у стварној апликацији да би донела неке функционалности. У овом смо чланку покренули сортирање мјехурића, сортирање одабира и брзу сорту, док постоји и неколико других алгоритама попут спајања сорти које се такође могу користити за генерисање сортиране листе. Међу свим алгоритмима за сортирање, куицксорт делује врло брзо и помаже да се листа сортира веома брзо. Овдје написани програми у основи су за имплементацију ових алгоритама сортирања помоћу програмског језика Ц. Ако сте вољни да примените исто у другим програмским језицима, можете да користите исту логику и једино што може варирати могу бити синтакса и кључне речи.

Препоручени чланак

Ово је водич за сортирање у Ц. Овде смо расправљали о уводу у Сортирање у Ц и различитим врстама сортирања заједно са кодом узорка. Можете и да прођете кроз друге наше предложене чланке да бисте сазнали више -

1. Обрасци у Ц програмирању
2. Палиндроме ин Ц програм
3. Спајање сортирања у Јави
4. Увод у сортирање у Р
5. Увод у сортирање у Ц ++
6. Преглед сортирања у ПХП-у
7. Хеап Сорт ин Питхон
8. Функција сортирања у Питхон-у са примерима