Как вывести отсортированный массив c

Сортировка массива методом пузырька

Ввести целочисленный массив из N ‘элементов с клавиатуры. Отсортировать его по возрастанию методом пузырька.

Исходный код на языке C++

/* * Ввести целочисленный массив из N целых чисел. * Отсортировать этот массив по возрастанию методом пузырька */ #include using namespace std; int main() < int *arr; // указатель для выделения памяти под массив int size; // размер массива // Ввод количества элементов массива cout > size; if (size arr = new int[size]; // выделение памяти под массив // заполнение массива for (int i = 0; i < size; i++) < cout > arr[i]; > int temp; // временная переменная для обмена элементов местами // Сортировка массива пузырьком for (int i = 0; i < size - 1; i++) < for (int j = 0; j < size - i - 1; j++) < if (arr[j] >arr[j + 1]) < // меняем элементы местами temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; >> > // Вывод отсортированного массива на экран for (int i = 0; i < size; i++) < cout cout 

Сортировка массива C#. Алгоритм «Сортировка выбором»

уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.

На данный момент у нас уже хватает знаний, чтобы попробовать написать простейшую программу в C#. Но, простейшая — не значит бесполезная. Наша программа будет сортировать массив C#. При написании различных программ нам часто приходится сталкиваться с таким понятием как сортировка. Например, необходимо отсортировать список людей по алфавиту или произвести сортировку оценок учащихся по возрастанию. И для того, чтобы максимально эффективно решить такую задачу мы должны знать не только сам язык программирования, но и алгоритмы сортировки — их сложность, как они реализуются на практике и так далее. Сегодня мы рассмотрим самый простой алгоритм сортировки массива C# — сортировку выбором.

Задача

Пользователь вводит с клавиатуры целые числа, разделенные запятой. Программа должна собрать из этих чисел массив и отсортировать его по возрастанию.

В консоль программа выведет неотсортированный и отсортированный массивы.

Алгоритм «Сортировка выбором»

Этот алгоритм является одним из самых простейших алгоритмов сортировки массива. Его смысл заключается в том, чтобы, чтобы идти по массиву, например слева направо, каждый раз искать минимальный элемент массива и обменивать его с первым элементом неотсортированной части массива. Шаги алгоритма можно представить следующим образом:

1. Находим минимальный элемент в массиве.
2. Меняем местами минимальный и первый элемент местами.
3. Ищем минимальный элемент в неотсортированной части массива, т.е., начиная уже со второго элемента массива.
4. Меняем местами второй элемент массива и найденный минимальный.
5. Ищем минимальный элемент в массиве, начиная с третьего, меняем местами третий и минимальный элементы.
6. Продолжаем алгоритм до тех пор пока не дойдем то конца массива.

Реализация алгоритма сортировки выбором в C#

Вначале приведу реализацию алгоритма сортировки массивы выбором в C#. Код постарался максимально пояснить с помощью комментариев:

//intArray - это массив целых чисел int indx; //переменная для хранения индекса минимального элемента массива for (int i = 0; i < intArray.Length; i++) //проходим по массиву с начала и до конца < indx = i; //считаем, что минимальный элемент имеет текущий индекс for (int j = i; j < intArray.Length; j++) //ищем минимальный элемент в неотсортированной части < if (intArray[j] < intArray[indx]) < indx = j; //нашли в массиве число меньше, чем intArray[indx] - запоминаем его индекс в массиве >> if (intArray[indx] == intArray[i]) //если минимальный элемент равен текущему значению - ничего не меняем continue; //меняем местами минимальный элемент и первый в неотсортированной части int temp = intArray[i]; //временная переменная, чтобы не потерять значение intArray[i] intArray[i] = intArray[indx]; intArray[indx] = temp; >

Проверить работу алгоритма нам поможет небольшая консольная программка в C#, которую мы сейчас и напишем.

Программа сортировки массива C# выбором

По условию задачи пользователь может ввести любое количество целых чисел, разделенных запятыми. Нам необходимо прочитать эти числа, составить из полученных чисел массив, вывести его в консоль, отсортировать массив приведенным выше алгоритмом и вернуть в консоль отсортированный массив. Все эти шаги реализуются достаточно просто.

Собираем массив целых чисел

Console.WriteLine("Введите через запятую целые числа и нажмите Enter"); string[] nums = Console.ReadLine().Split(new char[] < ',' >); int[] intArray = new int[nums.Length]; for (int i = 0; i

В первой строке мы предлагаем пользователю ввести целые числа. После того, как пользователь введет любое количество чисел и нажмет Enter, программа переходит к следующему шагу — разделит полученную от пользователя строку на массив строк:

string[] nums = Console.ReadLine().Split(new char[] < ',' >);

Метод Console.ReadLine() возвращает нам последнюю строку из консоли.

Метод Split(new char[] < ',' >) — это метод для типа string , который возвращает массив строк, созданный из исходной строки. В качестве аргумента этот метод принимает массив символов по которым будет делиться строка. Так как у нас, по условиям задачи, разделитель всего один — запятая, то и массив разделителей в методе Split() содержит всего один элемент.

На следующем шаге мы создаем массив целых чисел размер которого совпадает с размером массива nums .

int[] intArray = new int[nums.Length]

Далее, в цикле for мы наполняем наш созданный массив числами, используя метод Parse() у типа данных int , который возвращает нам целое число из строки.

for (int i = 0; i

Выводим неотсортированный массив в консоль

Вывести неотсортированный массив пользователю проще простого, если воспользоваться циклом foreach :

Console.WriteLine("Неотсортированный массив:"); foreach (int value in intArray) < Console.Write($""); >

Сортируем массив, используя алгоритм «Сортировка выбором» и показываем результат

Для этого используем реализацию алгоритма, которая представленная выше. Чтобы вывести отсортированный массив пользователю снова используем цикл foreach .

Console.WriteLine("\r\nОтсортированный массив:"); foreach (int value in intArray) < Console.Write($""); >

так как для неосортированного массива мы использовали метод Console.Write() , которые не производит переход на следующую строку, то здесь, в методе Console.WriteLine() мы использовали управляющие символы C# /r/n для перехода на новую строку и возврат каретки в начало строки.

Результат работы программы

В результате работы программы можно получить, например, вот такой вывод в консоли:

Введите через запятую целые числа и нажмите Enter

Неотсортированный массив: 0 100 999 345 -100 1 0 9 7 6 5 4 3 2 1 67 88

Отсортированный массив: -100 0 0 1 1 2 3 4 5 6 7 9 67 88 100 345 999

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

Исходный код программы

Ниже приведен весь исходный код программы C# для сортировки массива:

using System; namespace SelectSort < class Program < static void Main(string[] args) < Console.WriteLine("Введите через запятую целые числа и нажмите Enter"); string[] nums = Console.ReadLine().Split(new char[] < ',' >); int[] intArray = new int[nums.Length]; for (int i = 0; i < nums.Length; i++) < intArray[i] = int.Parse(nums[i]); >Console.WriteLine("Неотсортированный массив:"); foreach (int value in intArray) < Console.Write($""); > int indx; //переменная для хранения индекса минимального элемента массива for (int i = 0; i < intArray.Length; i++) //проходим по массиву с начала и до конца < indx = i; //считаем, что минимальный элемент имеет текущий индекс for (int j = i; j < intArray.Length; j++) //ищем минимальный элемент в неотсортированной части < if (intArray[j] < intArray[indx]) < indx = j; //нашли в массиве число меньше, чем intArray[indx] - запоминаем его индекс в массиве >> if (intArray[indx] == intArray[i]) //если минимальный элемент равен текущему значению - ничего не меняем continue; //меняем местами минимальный элемент и первый в неотсортированной части int temp = intArray[i]; //временная переменная, чтобы не потерять значение intArray[i] intArray[i] = intArray[indx]; intArray[indx] = temp; > Console.WriteLine("\r\nОтсортированный массив:"); foreach (int value in intArray) < Console.Write($""); > > > >

Также, Вы можете загрузить исходный код приложения из нашего репозитория на Github.

Итого

Сегодня мы написали своё первое полноценное приложение на C# для сортировки массива. Как видите, для этого нам пригодилось всё, что мы изучали ранее — переменные, работа с массивами, литералы, циклы и так далее. Постепенно, наши программы будут «обрастать» новыми возможностями, станут более устойчивыми к различным ситуациям (например, сегодня я даже не пытался проверить то, что ввел пользователь, хотя такую проверку необходимо проводить). Но всё это будет делаться постепенно, по мере изучения возможностей C#.

уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.

Алгоритм пузырьковой сортировки одномерного массива на C++

Здравствуй, дорогой гость. В этой статье я расскажу об алгоритме сортировки массива методом пузырька.

Элементы массива, как пузырьки

Алгоритм пузырьковой сортировки — это довольно простой в реализации алгоритм для сортировки массивов. Можно встретить и другие названия: пузырьковая сортировка, Buble sort или сортировка простыми обменами — но все они будут обозночать один и тот же алгоритм. Назван так, потому что большее или меньшее значение «всплывает» (сдвигается) к краю массива после каждой итерации, это будет видно в примере.

Сложность этого алгоритма выражается формулой О(n^2) (n в степени 2). Алгоритм работает медленно с большими массивами, а поэтому малоэффективен и на практике используется редко, чаще всего в учебных целях. Для сортировки массивов на практике используют другие более быстрые алгоритмы, один из них — QuickSort(быстрая сортировка). Функция для быстрой сортировки включена во многие стандартные библиотеки языков программирования, например в языке C функция qsort() из стандартной библиотеки.

Алгоритм работает очень просто. Программа проходит по всем элементами массива по порядку. Каждый текущий элемент сравнивается с соседним и, если он меньше/больше(если сортируем по убыванию/возрастанию соответственно) меняется местами с соседним.

Пример работы алгоритма пузырьковой сортировки

Рассмотрим пример работы алгоритма с массивом, состоящим из четырех элементов.

Имеется массив [4, 5, 2, 6]. Сортировать его будем по убыванию.

N — количество элементов в массиве. i — номер прохода. Алгоритм будет делать проходы по массиву, всего N-1 проходов до N-i ячейки в каждой итерации для любого массива.

Первый проход циклом от первого до N-1 элемента, сравнение условием и перемена местами в случае удовлетворения условия — если левый элемент меньше правого.

4 5 2 6

Сравниваем 4 и 5, 4 меньше 5, а значит мы их меняем местами.

5 4 2 6

Сравниваем 4 и 2, 4 не меньше 2, а значит пропускаем и идем дальше.

5 4 2 6

Сравниваем 2 и 6, 4 меньше 6, а значит мы их меняем местами.

Теперь мы у нас массив [5, 4 ,6, 2]. Как видно, он еще не упорядочен до конца. После первого прохода в конец массива передвинулось самое маленькое значение, теперь нам нужно сделать еще проход до элемента N-2 (ведь идет 2-ая итерация).

Делаем проход, начиная с первого элемента.

5 4 6 2

Сравниваем 5 и 4, 5 не меньше 4, а значит пропускаем и идем дальше.

5 4 6 2

Сравниваем 6 и 4, 6 меньше 4, а значит мы их меняем местами. Мы достигли элемента N-2, завершаем итерацию.

Теперь мы имеем массив [5, 6, 4, 2]. 2 последних элемента упорядочены как нужно. Для завершения нужно выполнить еще один проход до N-3.

5 6 4 2

Сравниваем 5 и 6, 5 меньше 6, а значит мы их меняем местами. Мы достигли элемента N-3, завершаем итерацию.

В итоге на выходе мы получили массив упорядоченный по убыванию — [6, 5, 4, 2].

Реализация алгоритма на языке C++

Программа выполнит последовательно следующие действия:

1. Установит размер массива, прося пользователя ввести числовое значение.
2. Заполнит массив значениями, введенными пользователем для каждого элемента массива.
3. Выведет исходный массив.
4. Отсортирует массив по убыванию.
5. Выведет отсортированный массив.

Теперь собственно код по каждому из пунктов.

1. Объявим переменную и инициализируем её значение данными, введенными пользователем.

/* Установим размер массива */ int n; // Кол-во элементов cout > n;

2. Объявим массив из количества элементов, которое ввел пользователь. А то есть объявим массив из n элементов. После запустим цикл и попросим пользователя ввести значение каждого элемента.

/* Заполним массив значениями */ int mass[n]; for(int i = 0; i < n; ++i) < cout > mass[i]; >

3. Выведем значения всех элементов массива, используя цикл.

/* Выведем исходный массив */ cout cout 
4. Отсортируем массив по убыванию. Здесь нам понадобятся 2 цикла. Первый будет выполнять количество итераций n-1, как в примере выше, который мы разобрали. Второй цикл будет осуществлять проходы по элементам массива (таких проходов n-i) и сравнивать соседние элементы. Элементы сравниваются условием, если i-ый элемент меньше правого соседа, то они меняются местами, таким образом самый маленький элемент будет в правой крайней части.
/* Отсортируем массив по убыванию */ for(int i = 1; i < n; ++i) < for(int r = 0; r < n-i; r++) < if(mass[r] < mass[r+1]) < // Обмен местами int temp = mass[r]; mass[r] = mass[r+1]; mass[r+1] = temp; >> >
5. Выведем отсортированный массив, используя цикл, как в 3-ем действии.
/* Выведем отсортированный массив */ cout cout 
Весь код программы
#include using namespace std; int main() < /* Установим размер массива */ int n; // Кол-во элементов cout > n; /* Заполним массив значениями */ int mass[n]; for(int i = 0; i < n; ++i) < cout > mass[i]; > /* Выведем исходный массив */ cout cout > > /* Выведем отсортированный массив */ cout cout
Обратите внимание, что в коде программы использовались русские символы, если у вас их отображение некорректно, то почитайте статью про решение проблемы с отображением русских символов в консоли.
Написание программы завершено, теперь проверим результаты. А для этого введем в программу массив, сортировку которого мы произвели, рассматривая пример работы алгоритма немного выше в этой статье.
После ввода данных и выполнения программы мы получили результат.

Результат сортировки массива методом пузырька
Как видно на картинке, массив отсортирован по убыванию. Программа работает.
Как я отмечал ранее, алгоритм работает очень медленно с большим объемом данных, а потому непригоден для использования на практике, а пригоден лишь в обучающих и ознакомительных целях. Посмотрите на решения других задач по программированию.
Для вас это может быть интересно:
Раздел: Алгоритмы Программирование Метки: Buble, C++, алгоритм, программирование, Сортировка
Алгоритм пузырьковой сортировки одномерного массива на C++ : 21 комментарий

  
Tima 13.09.2016 Везде о ней пишут, но по быстродействию она уступает любым другим. Напишите о QuickSort, будет полезно ��


  
Nicknixer Автор записи 15.09.2016 Да, действительно, по быстродействию она уступает многим другим. QuickSort в планах есть, в скором будущем.


  
Марсель 30.05.2017 if(mass[r] < mass[r+1])
поменять здесь знак сравнения на противоположный


Как вывести отсортированный массив c
Познакомившись с циклами, переменными, условными конструкциями и массивами, рассмотрим несколько задач для работы с массивами.
Количество положительных чисел
Найдем количество положительных чисел в массиве:
int[] numbers = < -4, -3, -2, -1, 0, 1, 2, 3, 4 >; int result = 0; foreach(int number in numbers) < if(number >0) < result++; >> Console.WriteLine($"Число элементов больше нуля: ");
Здесь создаем вспомогательную переменную result , которая будет содержать количество положительных чисел. В цикле прохожим по массиву и, если его элемент больше нуля, добавляем к переменной result единицу.
Инверсия массива
Вторая задача - инверсия массива, то есть переворот его в обратном порядке:
int[] numbers = < -4, -3, -2, -1,0, 1, 2, 3, 4 >; int n = numbers.Length; // длина массива int k = n / 2; // середина массива int temp; // вспомогательный элемент для обмена значениями for(int i=0; i < k; i++) < temp = numbers[i]; numbers[i] = numbers[n - i - 1]; numbers[n - i - 1] = temp; >foreach(int i in numbers) < Console.Write($"\t"); >
Поскольку нам надо изменять элементы массива, то для этого используется цикл for. Алгоритм решения задачи подразумевает перебор элементов до середины массива, которая в программе представлена переменной k, и обмен значений элемента, который имеет индекс i, и элемента с индексом n-i-1.
Программа сортировки массива
Теперь возьмем задачу посложнее - простейшую сортировку массива:
int[] nums = < 54, 7, -41, 2, 4, 2, 89, 33, -5, 12 >; // сортировка int temp; for (int i = 0; i < nums.Length - 1; i++) < for (int j = i + 1; j < nums.Length; j++) < if (nums[i] >nums[j]) < temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; >> > // вывод Console.WriteLine("Вывод отсортированного массива"); for (int i = 0; i
Для сортировки массива выполняем проходы по массиву и сравниваем элементы. Поскольку нам надо последовательно сравнивать каждый элемент массива с каждым (за исключением сравния с самим собой), то здесь применятся вложенный цикл.
Во внешнем цикле мы берем элемент, который будем сравнивать:
for (int i = 0; i < nums.Length - 1; i++)
Далее запускаем вложенный цикл, который начинается, со следующего элемента, и из которого извлекаем элементы, с которыми будем сравнивать тот элемент, которые берется из массива во внешнем цикле:
for (int j = i + 1; j < nums.Length; j++)
Если элемент с меньшим индексом больше элемента с большим индексом, то меняем элементы местами.
if (nums[i] > nums[j])
В конце выводим все элементы.


Похожие публикации:

Как вернуть старый дизайн фаерфокс
Как настроить live server в vscode
Как паять медные трубки холодильника
Как перевести visual studio на английский