Sortowanie w C - Różne rodzaje sortowania wraz z przykładem

• Wprowadzenie do sortowania w C

Wprowadzenie do sortowania w C

W aplikacji programiści odczuwają potrzebę sortowania danych w celu zapewnienia określonej funkcjonalności. Istnieje kilka podejść do sortowania danych i są one liczone podczas sortowania zgodnie z nomenklaturą. Sortowanie można zdefiniować jako metodę porządkowania danych w określony sposób, który następuje w określonej kolejności. W tym rozdziale dowiemy się o sortowaniu przy użyciu języka programowania C. Istnieje kilka rodzajów sortowania, takich jak sortowanie bąbelkowe, sortowanie scalone, sortowanie selekcyjne, sortowanie wstawiane i tak dalej. Dokonamy rzeczywistego kodowania dla metod sortowania, które są bardzo często używane w aplikacji. Kody będą dostępne w formacie tekstowym, dzięki czemu można łatwo użyć tego kodu, a dane wyjściowe zostaną wyświetlone na zrzucie ekranu, aby zapewnić wgląd w rzeczywiste dane wyjściowe po uruchomieniu programu.

Jak odbywa się sortowanie w C?

• Sortowanie można przeprowadzać na różne sposoby w oparciu o algorytm sortowania. W języku programowania C mamy kilka metod sortowania listy. Termin sortowanie oznacza porządkowanie danych w określony sposób, zwykle w porządku rosnącym. Chociaż sposób sortowania danych jest różny we wszystkich algorytmach sortowania, wynik wszystkich z nich jest taki sam.
• Zwykle podczas sortowania program wyszukuje minimalną liczbę i przesuwa tę liczbę na początek listy i powtarza te same wyszukiwania. Znów po napotkaniu drugiej małej liczby jest ona przenoszona do następnej spacji na liście zaraz po pierwszym indeksie i proces ten powtarza się aż do uzyskania listy sortowania. W ten sposób sortowanie odbywa się w języku programowania C.
• We wszystkich podejściach do sortowania listy tablica odgrywa bardzo istotną rolę w języku programowania C. W każdym algorytmie tablica służy do przechowywania listy elementów, które należy posortować. Na przykład w sortowaniu bąbelkowym elementy są przechowywane w pojedynczej tablicy, a wartości w tablicy zostały przetworzone w celu przekształcenia ich w listę posortowanych danych.
• W sortowaniu selekcyjnym ta sama tablica została potraktowana jako dwie tablice, w których pierwsza tablica jest uważana za pustą w celu podania posortowanych wartości, podczas gdy druga tablica zawiera nieposortowaną listę. W celu posortowania tablica jest używana bardzo często zamiast utrzymywania wartości w poszczególnych zmiennych. Spośród wszystkich algorytmów szybkie sortowanie działa bardzo szybko i dlatego nazywane jest szybkim sortowaniem. Zajmuje to znacznie mniej czasu w porównaniu z innymi algorytmami sortowania.

Rodzaje sortowania w C

1. Sortowanie bąbelkowe

• Sortowanie bąbelkowe może być zdefiniowane jako algorytm sortowania, który polega na zamianie wartości w pierwszym indeksie na najmniejszą wartość w tablicy i powtarzanie jej aż do posortowania listy. Jest to bardzo prosty sposób przeprowadzania sortowania. W ten sposób, aby posortować tablicę, wartość należy przypisać do tablicy na początku przed rozpoczęciem sortowania.
• Poniżej znajduje się program do sortowania tablicy za pomocą sortowania bąbelkowego, w którym wartości zostały pobrane od użytkownika. Po skompilowaniu i uruchomieniu program zapyta użytkownika o liczbę elementów, które chce posortować. Po podaniu liczby program poprosi użytkownika o podanie wartości równoważnych podanej liczbie. Wartości zostaną zapisane w tablicy i będą przetwarzane dalej za pomocą zagnieżdżonej pętli for wraz z podejmowaniem decyzji za pomocą „if” w celu posortowania tablicy.
• Pierwsza najmniejsza wartość znaleziona w tablicy została przeniesiona do pierwszego indeksu tablicy, a następnie wyszukiwanie rozpoczyna się od znalezienia drugiej najmniejszej liczby. Po znalezieniu kolejnej najmniejszej liczby zastępuje ona wartość z drugiego indeksu, a proces powtarza się, aż tablica składa się z posortowanej listy wartości.

Kod

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

Użytkownik przesłał dane wejściowe 5 3 60 14 1 2 645. Algorytm został zastosowany do tablicy składającej się z wartości w sposób podany przez użytkownika, a po przetworzeniu otrzymane dane wyjściowe wynoszą 1 2 3 5 14 60 645 .

Wynik:

2. Wybór sortowania

• Sortowanie wyboru można zdefiniować jako inny algorytm sortowania listy, w której tablica jest podzielona na dwie tablice, w których pierwsza tablica ma być pusta, podczas gdy druga tablica składa się z nieposortowanej listy wartości. Program wyszukuje najmniejsze wartości w drugiej tablicy, a po znalezieniu wartości został przeniesiony na początek pierwszej pustej tablicy. Podejście to jest powtarzane ponownie, a następne najmniejsze wartości zostaną przesunięte do drugiego indeksu pierwszej tablicy. Procesy będą się powtarzać, aż druga tablica stanie się pusta.
• Poniższy program jest implementacją kodowania algorytmu sortowania selekcji. Gdy program uruchomi się pomyślnie, poprosi użytkownika o podanie liczby wartości, które chce posortować. Po uzyskaniu liczby program poprosi użytkownika o wprowadzenie wartości dla tablicy, która ma zostać posortowana. Wartość jest następnie przetwarzana za pomocą zagnieżdżonej pętli for w celu posortowania liczb. W tym przypadku również sprawdzono warunek if, aby sprawdzić najmniejszą liczbę.
• Procesy będą powtarzane, aż pierwsza lista będzie pełna posortowanej listy. Tymczasem programy nadal koncentrują się na sprawdzaniu, czy druga tablica ma wartość, a jeśli jest dodatnia, program ponownie uruchamia algorytm sortowania. Chociaż sortuje listę w łatwy sposób, może to zająć nieco więcej czasu w porównaniu do innych algorytmów. Ale do końca wynik, który wygeneruje, będzie taki sam, jak innych algorytmów sortowania.

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

Pytając o liczbę elementów, które należy posortować, użytkownik podał 6 w wynikach poniżej. Później wartości, które zostały wprowadzone to 25 65 36 86 96 45. Wartości te są przechowywane w tablicy, która ma być podzielona na dwie tablice, gdzie jedna będzie pusta do przechowywania posortowanej listy, a druga będzie miała nieposortowaną listę . Po przetworzeniu danych wejściowych wynik wyniósł 25 36 45 65 86 96. Ta utrata została posortowana przy użyciu sortowania selekcyjnego. Po przeniesieniu wszystkich sześciu wartości do pierwszej tablicy w postaci posortowanej druga tablica stanie się pusta, a algorytm zostanie zakończony.

Wynik:

3. Szybkie sortowanie

• Quicksort może być zdefiniowany jako inny algorytm do sortowania listy, w której podejście polega na podzieleniu tablicy pod względem wartości większych i mniejszych od wartości, aż zostaną podzielone na poszczególne wartości. W tym algorytmie wartość ostatniego indeksu tablicy została wybrana jako oś przestawna, a wszystkie wartości mniejsze niż oś przestawiona zostały przeniesione do tablicy, która ma wystąpić po lewej stronie wartości, a elementy o wyższej wartości wtedy oś przestawiona jest na prawą tablicę. Ponownie jeden element przestawny jest wybierany z nowo utworzonej tablicy, która miała wartości mniejsze niż ostatnia wartość przestawna. Podobnie wartości mniejsze niż nowy element przestawny zostaną przesunięte do tablicy, która pozostanie, a wartości większe niż nowy element przestawny zostaną przesunięte w prawej tablicy.
• Poniższy program to szybka implementacja przy użyciu języka programowania C. Po uruchomieniu program zapyta użytkownika o liczbę elementów, które chce posortować. Na podstawie liczby pętla for będzie iterować szacunkowe czasy pobierania danych wejściowych od użytkownika. Dane wejściowe będą przetwarzane przy użyciu warunków if wraz z pętlą for w celu wygenerowania posortowanej listy. Tablica będzie ustawiać wartości za pomocą wartości przestawnej, dopóki wszystkie wartości nie zostaną sprawdzone pod kątem najmniejszej wartości.
• Sortowanie za pomocą tego algorytmu jest o wiele szybsze w porównaniu z innymi algorytmami sortowania i dlatego nazwano go szybkim sortowaniem. Quicksort jest jedynym algorytmem, który prowadzi do dzielenia tablicy, dopóki wszystkie wartości nie zostaną rozdzielone na poszczególne tablice. Będą one następnie dodawane lub agregowane w jednej tablicy, która jest uważana za posortowaną listę.

Kod:

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

W wynikach poniżej użytkownik potwierdził, że prześle 6 wartości i utworzy listę posortowanych danych. Po podaniu liczby wartości podane przez użytkownika wynoszą 56, 35, 24, 86, 98, 2. Do tych wartości zastosowano Quicksort i wygenerowano posortowaną listę o wartości 2, 24, 35, 56, 86, 98.

Wynik:

4. Scal sortowanie

• Scalanie sortowania można zdefiniować jako inny algorytm sortowania, który wykonuje sortowanie, segregując tablicę do końca, kiedy zamienia się ona w pojedynczą wartość, a następnie agreguje je w taki sposób, aby przekształcić się w sortowaną tablicę.
• Proces zajmuje nieco więcej czasu w porównaniu z innymi rywalizującymi algorytmami, ale jest uważany za dość wydajny w porównaniu do innych. Jeśli chodzi o sortowanie dużej listy, ten algorytm działa bardzo dobrze i dlatego jest preferowany w tworzeniu aplikacji, która musi przetwarzać dużą listę.

Kod:

#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);
)
Po uruchomieniu powyższego kodu najpierw prosi użytkownika o podanie liczby elementów, które chce posortować. Po przesłaniu numeru będą musieli podać wartości równej liczby, które podali na początku. Po przesłaniu wartości algorytm przechowa te wartości w tablicy i przetworzy ją w celu przekształcenia tablicy w posortowaną tablicę. Po posortowaniu tablicy w porządku rosnącym dane wyjściowe zostaną wyświetlone użytkownikowi.

Wynik:

5. Heapsort

• Sortowanie sterty można zdefiniować jako algorytm sortowania, który działa, wyszukując maksymalny element na liście i umieszczając go na ostatnim. Algorytm wykonuje akcję rekurencyjnie, dopóki tablica nie zostanie posortowana w sposób rosnący.
• Bardzo dużo czasu zajmuje proces wybrania maksymalnej wartości i przeniesienia jej do ostatniej, dlatego jest ona uważana za mniej wydajne podejście do sortowania, jeśli chodzi o sortowanie dużej listy. Działa to jednak dobrze z listą, która ma ograniczoną liczbę wartości. Poniżej przedstawiono implementację tego algorytmu w języku programowania C wraz z danymi wyjściowymi.

Kod:

#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;
)
)
)
Działanie tego algorytmu jest takie samo jak w przypadku innych algorytmów sortowania, ponieważ sortuje on również listę w porządku rosnącym. Po uruchomieniu powyższego kodu użytkownik musi podać liczbę wartości, które będzie sortował. Po przesłaniu wartości kod przetworzy je w celu przekształcenia tablicy w posortowaną. Dane wyjściowe zostaną ostatecznie wyświetlone i można zaobserwować, że wartości przesłane przez użytkownika zostały posortowane w porządku rosnącym.

Wynik:

6. Wstawianie Sortuj

• Sortowanie wstawiania można zdefiniować jako algorytm sortowania, który działa, przesuwając minimalną wartość na początku listy pojedynczo. Jest to bardzo mniej wydajny algorytm sortowania i nie jest odpowiedni do obsługi dużej listy.
• Takie podejście do sortowania algorytmu działa bardzo wolno i zwykle nie jest preferowane w żadnej z aplikacji. Może działać dobrze z listą, która ma dość niewiele elementów. W przypadku aplikacji, które wymagają przetworzenia kilku liczb wartości, można wykorzystać ten algorytm.

Kod:

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

Po uruchomieniu programu użytkownik będzie musiał wprowadzić liczbę wartości, które musi posortować. Następnie wartości wprowadzone przez użytkownika zostaną zapisane w tablicy. Następnie będą przetwarzane, a przy użyciu sprawdzania pętli i sprawdzania warunków minimalna wartość zostanie przesunięta na początek w każdej rekurencji i zakończy się generowaniem posortowanej tablicy. Wartości zostaną wyświetlone użytkownikowi na końcu programu.

Wynik :

Wniosek

Algorytm sortowania służy do generowania posortowanej listy, która jest normalną listą, w której wszystkie wartości są sortowane w określony sposób. Lista była bardzo często używana w rzeczywistej aplikacji, aby zapewnić pewne funkcje. W tym artykule omówiliśmy sortowanie bąbelkowe, sortowanie selekcji i szybkie sortowanie, podczas gdy istnieje również kilka innych algorytmów, takich jak sortowanie scalone, które można wykorzystać do wygenerowania posortowanej listy. Wśród wszystkich algorytmów sortowania szybkie sortowanie działa bardzo szybko i pomaga bardzo szybko posortować listę. Programy tutaj napisane mają zasadniczo zaimplementować te algorytmy sortowania przy użyciu języka programowania C. Jeśli chcesz wdrożyć to samo w innych językach programowania, możesz użyć tej samej logiki, a jedyną różnicą może być składnia i słowa kluczowe.

Polecany artykuł

To był przewodnik po sortowaniu w C. Tutaj omawiamy wprowadzenie do sortowania w C i różne typy sortowania wraz z przykładowym kodem. Możesz także przejrzeć nasze inne sugerowane artykuły, aby dowiedzieć się więcej -

1. Wzory w programowaniu C.
2. Program Palindrome in C.
3. Scal sortowanie w Javie
4. Wprowadzenie do sortowania w R.
5. Wprowadzenie do sortowania w C ++
6. Przegląd sortowania w PHP
7. Sortuj sterty w Pythonie
8. Funkcja sortowania w Pythonie z przykładami