printf("\n ");

puts ("Читаем из файла");

while ((fnumber = fgetc(file))!= EOF) // Пока не конец файла читаем число //из файла

{ printf ("%x\t",fnumber); // Выводим его на экран

} fsum = fsum + fnumber; // Считаем сумму чисел fclose (file); // Закрыли файл

file = fopen( file_name, "a" ); // Открываем файл для дополнения fputs("Сумма значений равна \n", file); // Выводим в конец файла fprintf(file, "%s\n", &fsum);

printf("\n ");

fclose (file); // Закрыли файл puts("Готово"); system("pause");

}

На экране будет отображен следующий диалог:

Сколько чисел будем вводить : 5 Введите число 1 : 5 Введите число 2 : 4 Введите число 3 : 3 Введите число 4 : 2 Введите число 5 : 1

Читаем из файла 5 4 3 2 1

Готово!

При этом файл a.txt будет сожержать следующие строки:

5

4

3

2

1 Сумма значений равна

15

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

Тема 10. Приемы программирования. Примеры алгоритмов

Алгоритмы сортировки

Задача сортировки ставится следующим способом. Пусть имеется массив целых или вещественных чисел a1,...,an. Требуется переставить элементы этого массива так, чтобы после перестановки они были упорядочены по неубыванию: а1 ≤ a2 ≤ ... ≤an или невозрастанию: а1 ≥ a2 ≥ ... ≥an. Если числа попарно различны, то говорят об упорядочении по возрастанию или убыванию. В дальнейшем

137

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

Сортировка обменами (пузырьком)

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

После первого прохода по массиву "вверху" (в начале массива) оказывается самый "легкий" (минимальный) элемент – отсюда аналогия с пузырьком, который всплывает (рис.37). Следующий проход делается до второго сверху элемента, таким образом, второй по величине элемент поднимается на правильную позицию и так далее.

Рис. 37. Сортировка массива методом «пузырька»

138

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

//процедура сортировки обменами (пузырьком) void SortBubble (int count, int* pArr)

{

int trash = 0;

for (int i = 0; i < count; i++) // i - номер прохода

{ for (int j=0; j < count-i-1; j++) // внутренний цикл прохода { if (pArr[j] > pArr[j+1]) //если "левый" больше "правого"

{ trash = pArr[j]; //меняем местами элементы pArr[j] = pArr[j+1];

} } }

}

pArr[j+1] = trash;

Сортировка выбором

Сортировка выбором выполняется несколько быстрее, чем сортировка методом пузырька. Алгоритм заключается в следующем: нужно найти элемент массива, имеющий наименьшее значение, переставить его с первым элементом, затем проделать тоже самое, начав со второго элемента и т.д. Таким образом, создается отсортированная последовательность путем присоединения к ней одного элемента за другим в правильном порядке. На i-м шаге выбирается наименьший из элементов a[i] ... a[n] и меняем его местами с a[i]. Последовательность шагов изображена на рис.38.

139

Рис. 38. Результат сортировки выбором

Вне зависимости от номера текущего шага i, последовательность a[0]...a[i] является упорядоченной. Таким образом, на (n-1)-м шаге вся последовательность, кроме a[n] оказывается отсортированной, а a[n] стоит на последнем месте по праву: все меньшие элементы уже ушли влево.

//процедура сортировки выбором

void SortSelect(int count, int* pArr)

{

int i1,temp; int jmax;

for (int i = count - 1; i > 0; i--) // i - номер текущего шага

{ jmax = 0;

for (int j = 0; j <= i; j++)

{

} if (pArr [jmax] < pArr [j]) i1 = j;

temp = pArr [i1]; pArr [i1] = pArr [i];

}} pArr [i] = temp;

Сортировка простыми вставками

Просматривается массив и каждый новый элемент a[i] вставляется на подходящее место в уже упорядоченную совокупность a[1],...,a[i-1]. Это место определяется последовательным сравнением a[i] с упорядоченными элементами a[1],...,a[i-1]. Таким образом в начале массива "вырастает" отсортированная последовательность.

Однако в сортировке пузырьком или выбором можно было четко заявить, что на i-м шаге элементы a[1]...a[i-1]стоят на правильных местах и никуда более не переместятся. Здесь же подобное утверждение будет более слабым: последовательность a[1]...a[i-1] упорядочена. При этом по ходу алгоритма в нее будут вставляться (см. название метода) все новые элементы.

Рассмотрим действия алгоритма на i-м шаге. Как говорилось выше, последовательность к этому моменту разделена на две части: готовую a[1]...a[i-1] и неупорядоченную a[i]...a[n].

140

На следующем, i-м каждом шаге алгоритма берем a[i] и вставляем на нужное место в готовую часть массива. Поиск подходящего места для очередного элемента входной последовательности осуществляется путем последовательных сравнений с элементом, стоящим перед ним. В зависимости от результата сравнения элемент либо остается на текущем месте (вставка завершена), либо они меняются местами и процесс повторяется (рис.39).

Таким образом, в процессе вставки мы "просеиваем" элемент X к началу массива, останавливаясь в случае, когда

1.Hайден элемент, меньший X.

2.Достигнуто начало последовательности.

//процедура сортировки простыми вставками void SortInsert (int count, int* pArr)

{

int temp, j;

for (int i = 1; i < n; i++) // цикл проходов, i - номер прохода

{ temp = pArr[i];

j = i-1; // поиск места элемента в готовой последовательности while (j >= 0 && pArr[j] > temp)

{ pArr[j+1] = pArr[j]; // сдвигаем элемент направо, пока не дошли } --j;

// место найдено, вставить элемент } pArr[j+1] = temp;

}

141