Введение в сортировку в C
В приложении разработчики чувствуют необходимость сортировки данных, чтобы дать возможность использовать определенные функции. Существует несколько подходов к сортировке данных, и они учитываются при сортировке согласно номенклатуре. Сортировка может быть определена как метод организации данных определенным образом, который следует некоторому порядку. Здесь, в этом разделе, мы собираемся узнать о сортировке с использованием языка программирования C. Существует несколько типов сортировки: сортировка по пузырькам, сортировка по слиянию, сортировка по выбору, сортировка по вставке и т. Д. Мы сделаем реальное кодирование для методов сортировки, которые очень часто используются в приложении. Коды будут доступны вам в текстовом формате, чтобы вы могли легко использовать этот код, а выходные данные будут отображаться на снимке экрана, чтобы дать вам представление о фактических результатах, которые появляются после запуска программы.
Как сортировка выполняется в C?
- Сортировка может быть выполнена различными способами на основе алгоритма сортировки. В языке программирования C у нас есть несколько подходов для сортировки списка. Термин «сортировка» означает расположение данных определенным образом, обычно в порядке возрастания. Хотя способ сортировки данных различен во всех алгоритмах сортировки, результат их всех одинаков.
- Обычно при сортировке программа ищет минимальное число и смещает это число в начало списка и повторяет тот же поиск. Снова, когда встречается другое небольшое число, оно перемещается на следующий пробел в списке сразу после первого индекса, и этот процесс повторяется до тех пор, пока не будет получен список сортировки. Это способ сортировки на языке программирования Си.
- Во всех подходах к сортировке списка массив играет очень важную роль в языке программирования Си. В каждом алгоритме массив использовался для хранения списка элементов, которые должны быть отсортированы. Например, при пузырьковой сортировке элементы хранятся в одном массиве, а значения в массиве были обработаны для преобразования их в список отсортированных данных.
- В сортировке выбора один и тот же массив был обработан как два массива, где первый массив считается свободным, чтобы сообщить отсортированные значения, в то время как второй массив содержит несортированный список. Для целей сортировки массив используется очень часто вместо хранения значений в отдельных переменных. Среди всех алгоритмов быстрая сортировка работает очень быстро и поэтому называется быстрой сортировкой. Это занимает гораздо меньше времени по сравнению с другими алгоритмами сортировки.
Типы сортировки в C
1. Пузырьковая сортировка
- Пузырьковая сортировка может быть определена как алгоритм сортировки, который следует подходу замены значения в первом индексе наименьшим значением в массиве и повторения до тех пор, пока список не будет отсортирован. Это очень простой способ выполнения сортировки. Таким образом, чтобы отсортировать массив, значение должно быть присвоено массиву в начале, прежде чем начать сортировку.
- Ниже приведена программа для сортировки массива с использованием пузырьковой сортировки, где значения были взяты у пользователя. После того, как программа скомпилирована и запущена, она запросит у пользователя количество элементов, которые они хотят отсортировать. Как только число предоставлено, программа попросит пользователя предоставить значения, эквивалентные предоставленному им количеству. Значения будут сохранены в массиве и будут обрабатываться далее с использованием вложенного цикла for вместе с принятием решения с использованием «if» для сортировки массива.
- Первое наименьшее значение, найденное в массиве, было перемещено в первый индекс массива, а затем поиск начинается снова, чтобы найти другое наименьшее число. Как только найдено следующее наименьшее число, оно заменяет значение во втором индексе, и процесс повторяется до тех пор, пока массив не состоит из отсортированного списка значений.
Код
#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. Выбор сортировки
- Сортировка выбора может быть определена как другой алгоритм сортировки списка, в котором массив раздвоен на два массива, где первый массив должен быть пустым, а второй массив состоит из несортированного списка значений. Программа ищет наименьшие значения во втором массиве, и когда значение найдено, оно перемещается в начало первого массива, который был пустым. Подход повторяется снова, и следующие наименьшие значения будут смещены ко второму индексу первого массива. Процессы будут повторяться до тех пор, пока второй массив не станет пустым.
- Приведенная ниже программа является реализацией алгоритма сортировки выбора. После успешного запуска программа попросит пользователя ввести количество значений, которые они хотят отсортировать. Как только счет получен, программа попросит пользователя ввести значения для массива, который должен быть отсортирован. Затем значение обрабатывается с использованием вложенного цикла for для сортировки чисел. Здесь также была включена проверка условия if для проверки наименьшего числа.
- Процессы будут повторяться до тех пор, пока первый список не будет заполнен отсортированным списком. Между тем, программы сохраняют свой основной фокус, чтобы проверить, имеет ли второй массив значение, и если он будет найден положительным, программа снова запускает алгоритм сортировки. Хотя список сортируется простым способом, он может занять немного больше времени по сравнению с другими алгоритмами. Но в итоге результат, который он сгенерирует, будет таким же, как и у других алгоритмов сортировки.
Код#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. Быстрая сортировка
- Быстрая сортировка может быть определена как другой алгоритм сортировки списка, в котором подход заключается в разделении массива по значениям больше и меньше значений до тех пор, пока все значения не будут разделены на отдельные формы. В этом алгоритме значение последнего индекса массива было выбрано в качестве сводного, и все значения, меньшие, чем сводный, были смещены в массив, который, как ожидается, будет находиться слева от значения, и элементы, имеющие более высокое значение чем стержень смещен к правому массиву. Опять же, из вновь сформированного массива была выбрана одна точка, значения которой были меньше, чем значение последней точки поворота. Аналогично, значения, меньшие, чем у нового центра, будут смещены в массив, который будет оставлен, а значения, больше, чем у нового центра, будут смещены в правый массив.
- Приведенная ниже программа представляет собой реализацию быстрой сортировки с использованием языка программирования C. Как только программа запустится, она спросит пользователя о количестве элементов, которые он хочет отсортировать. Основываясь на количестве, цикл for будет повторять расчетное время, чтобы принять ввод от пользователя. Входные данные будут обрабатываться с использованием условий if вместе с циклом for для создания отсортированного списка. Массив будет продолжать упорядочивать значения, используя значение pivot, пока все значения не будут проверены на наименьшее значение.
- Сортировка, выполняемая с использованием этого алгоритма, выполняется намного быстрее по сравнению с другими алгоритмами сортировки, и поэтому она была названа быстрой сортировкой. Быстрая сортировка - единственный алгоритм, который приводит к разделению массива до тех пор, пока все значения не будут разделены на отдельные массивы. Затем они будут добавлены или объединены в один массив, который рассматривается как отсортированный список.
Код:
#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. Heapsort
- Сортировка кучи может быть определена как алгоритм сортировки, который работает путем поиска максимального элемента в списке и размещения его до последнего. Алгоритм выполняет действие рекурсивно, пока массив не будет отсортирован по возрастанию.
- Пришло время, чтобы процесс выбрал максимальное значение и переместил его к последнему, и, следовательно, он считается менее эффективным подходом сортировки, когда речь идет о сортировке большого списка. Тем не менее, он прекрасно работает со списком, который имеет ограниченное количество значений. Ниже приведена реализация этого алгоритма на языке программирования 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;
)
Когда программа запустится, пользователь должен будет ввести количество значений, которые ему нужно отсортировать. После этого введенные пользователем значения будут сохранены в массиве. Затем они будут обрабатываться, и с помощью цикла for и проверки условий минимальное значение будет перемещаться в начало каждой рекурсии и заканчиваться созданием отсортированного массива. Значения будут отображаться пользователю в конце программы.
Выход :
Вывод
Алгоритм сортировки используется для генерации отсортированного списка, который представляет собой обычный список, в котором все значения сортируются определенным образом. Список использовался очень часто в реальном приложении, чтобы принести некоторые функциональные возможности. В этой статье мы рассмотрели пузырьковую сортировку, выборочную сортировку и быструю сортировку, в то время как есть несколько других алгоритмов, таких как сортировка слиянием, которые также могут быть использованы для создания отсортированного списка. Среди всех алгоритмов сортировки быстрая сортировка работает очень быстро и помогает очень быстро сортировать список. Программы, написанные здесь, в основном для реализации этих алгоритмов сортировки с использованием языка программирования C. Если вы хотите реализовать то же самое в других языках программирования, вы можете использовать ту же логику, и единственное, что может отличаться, это синтаксис и ключевые слова.
Рекомендуемая статья
Это было руководство по Сортировке в C. Здесь мы обсуждаем введение в Сортировку в C и различные типы сортировки вместе с примером кода. Вы также можете просмотреть наши другие предлагаемые статьи, чтобы узнать больше -
- Шаблоны в C Программирование
- Палиндром в программе C
- Слияние сортировки в Java
- Введение в сортировку в R
- Введение в сортировку в C ++
- Обзор сортировки в PHP
- Сортировка кучи в Python
- Функция сортировки в Python с примерами