цепочка;
Такой цикл называется циклом с предусловием (циклом ПОКА) и изображается следующей схемой:
Условие – это логическое выражение, зависящее от переменных, входящих в цепочку. Цикл повторяется до тех пор, пока условие истинно. Значит, данное условие является условиемпродолжения цикла. Выполнение цикла заканчивается, если операторы цепочки изменяют значения переменных, входящих в условие, и оно становится ложным.
Цикл не выполняется ни разу, если условие было ложным с самого начала.
Цикл ПОКА превращается в бесконечный, если условие подобрано так, что оно всегда истинно.
В Java цикл с предусловием реализуется оператором цикла while:
While (условие)
оператор;
или
While (условие)
{
оператор;
оператор;
....
оператор;
}
Операторы, находящиеся между фигурными скобками, называются телом цикла.
Внимание!Условие всегда заключается в скобки и после него точка с запятой не ставится!
Если поставить точку с запятой после условия, то этот цикл, как правило, превращается в бесконечный, потому что в этом случае условие изменяться не будет.
Фигурные скобки используются в том случае, если после условия должна следовать цепочка операторов.
Действия оператора while:
1. проверяется выполнение условия,
2. если оно истинно, то выполняется оператор (цепочка), стоящий после него,
3. после его выполнения снова проверяется условие, и если оно снова истинно, то цикл повторяется,
4. если условие становится ложным, то цикл заканчивает работу.
Примеры:
1. вычислить сумму ста первых натуральных чисел:
s = 1 + 2 + 3 + … + 98 + 99 + 100
Пусть s – искомая сумма,
i – очередное число (изменяется от 1 до 100).
Тогда алгоритм решения задачи можно описать следующим образом:
a. обнуляем сумму s = 0,
b. берем первое число: i = 1,
c. добавляем в сумму это число: s = s + i,
d. увеличиваем очередное число на единицу: i = i+ 1,
e. если оно не больше 100, то снова добавляем его в сумму и повторяем цикл.
Представим этот алгоритм так:
s = 0;
i = 1;
ПОКА (i ≤ 100)
НАЧАЛО
s = s + i;
i = i + 1;
КОНЕЦ;
Схема алгоритма:
Программа:
int i=1, s=0;
while (i<=100)
{
s+=i;
i++;
}
System.out.printf(“/ns=%d i=%d”,s, i);
Результат решения задачи:
s=5050 i=101
Таким образом, выходим из этого цикла со значением i не 100, а 101.
Вместо цепочки:
s+=i;
i++;
можно использовать один оператор:
s+=i++;
Этот цикл можно превратить в бесконечный, если после условия поставить точку с запятой:
int i=1, s = 0;
while (i<=100);
{
s += i;
i++;
}
System.out.printf(“/ns=%d i=%d”,s, i);
Значение переменной i в этом случае меняться не будет – она останется равной единице, и поэтому условие (i<=100) всегда истинно.
2. вычислить сумму s всех цифр заданного натурального числа n
Пусть s – искомая сумма,
i – очередная цифра числа.
Тогда алгоритм решения задачи можно описать следующим образом:
1. обнуляем сумму s=0,
2. берем последнюю цифру числа, для чего определяем остаток от деления исходного числа на 10: i = n % 10,
3. добавляем в сумму найденную цифру: s = s + i,
4. уменьшаем число в 10 раз: n = n / 10,
5. повторяем цикл до тех пор, пока n > 0 – это и будет условием продолжения цикла.
Схема алгоритма:
Программа
int i, n, s = 0;
String input;
input=JOptionPane.showInputDialog("Введите целое положительное число:");
n=Integer.parseInt(input);
while (n>0)
{
i = n % 10;
s+=i;
n /= 10;
}
System.out.printf(“/ns=%d”,s);
3. ввести с клавиатуры по одному последовательность целых чисел (конец последовательности – число 0). Определить их сумму, максимальное и минимальное число, количество введенных чисел и их среднее арифметическое.
Пусть s – искомая сумма,
min, max – минимальное и максимальное из введенных чисел,
count – количество введенных чисел,
sred – среднее арифметическое,
n – очередное число.
Тогда алгоритм решения задачи можно описать следующим образом:
1. обнуляем сумму s = 0,
2. вводим первое число n,
3. если оно не равно нулю, то
4. принимаем его значение за min и max
5. количество введенных чисел count = 1
6. увеличиваем сумму на введенное число s = s + n
7. входим в цикл ввода:
8. вводим очередное число n,
9. если оно не равно нулю, то
10. количество введенных чисел увеличиваем на 1: count = count+1
11. увеличиваем сумму на введенное число s = s + n
12. если оно меньше min, то min = n,
13. если оно больше max, то max = n,
14. повторяем цикл до тех пор, пока n # 0 – это и будет условием продолжения цикла.
Создадим интерфейс этой задачи – взаимодействие программы с пользователем, то есть что должно выводиться на экран:
Первое число: 3
Очередное число: 8
Очередное число: 1
Очередное число: -2
Очередное число: 0
Сумма = 10
Количество чисел = 4
min = -2
max = 8
Среднее арифметическое = 2.50
Схема алгоритма: 
Программа
int min, max, n, count = 0;
double sred, s = 0.0;
String input;
input=JOptionPane.showInputDialog("Введите первое число:");
n=Integer.parseInt(input);
if (n==0) //если введено число 0, то
return 0; //выход из программы с результатом 0
//иначе
min = n; // за минимум и максимум принимаем
max = n; //первое введенное число
count = 1; //введено одно число
s += n;
while (n!=0) // пока введенное число - не ноль
{ // выполнять цикл
input=JOptionPane.showInputDialog("Введите очередное число:");
n=Integer.parseInt(input);
if (n==0)
break; // если введен ноль – выход из цикла ввода
count++; // количество введенных чисел
s += n; // сумма введенных чисел
if (n > max) // определение максимального числа
max = n;
if (n < min) // определение минимального числа
min = n;
}
System.out.printf(“\nСумма = %4.2f”, s);
System.out.printf(“\nКоличество чисел = %d”, count);
System.out.printf(“\nmin = %d”, min);
System.out.printf(“\nmax = %d”, max);
sred = (double)s/count; // определение среднего арифм.
System.out.printf(“\n Среднее арифметическое = %6.2f”,sred);
Часто встречающиеся ошибки программирования:
1. Использование после условия точки с запятой, что, как правило, приводит к появлению бесконечного цикла:
int i=1, s = 0;
while (i<=100);
{
s += i;
i++;
}
2. Условие не заключено в скобки:
int i=1, s = 0;
while i<=100
{
s += i;
i++;
}
3. Отсутствие фигурных скобок, в которые заключается тело цикла:
int i=1, s = 0;
while (i<=100)
s += i;
i++;
Это может привести к появлению бесконечных циклов.
4. Отсутствие в теле цикла оператора, изменяющего условие:
int i=1, s = 0;
while (i<=100)
{
s += i;
}
Это тоже приводит к появлению бесконечных циклов.
Циклы с постусловием
У циклов с постусловием (циклов типа ДО) проверка условия продолжения цикла производится после выполнения операторов, составляющих тело цикла:
ВЫПОЛНЯТЬ
Цепочка
ДО (условие);
Такой цикл повторяется до тех пор, пока условие истинно. Выполнение цикла заканчивается, если операторы цепочки изменяют значения переменных, входящих в условие, и оно становится ложным.
В любом случае этот цикл выполняется хотя бы один раз. Цикл с постусловием превращается в бесконечный, если условие подобрано так, что оно всегда истинно.
Таким образом, условие в данном цикле является условием его продолжения, как и в цикле с предусловием.
В Java цикл с постусловием реализован оператором цикла do:
do
{
оператор;
оператор;
оператор;
......
оператор;
}
while (условие);
где do – служебное слово выполнять,
while – служебное слово пока.
Внимание! После слова do точка с запятой не ставится!
Перед закрывающей фигурной скобкой }поставить точку с запятой!
Действия оператора do:
1. выполняется оператор (цепочка),
2. проверяется выполнение условия, стоящего после слова while,
3. если оно истинно, то цикл повторяется,
4. если условие становится ложным, то цикл заканчивает работу.
Примеры:
1. вычислить сумму ста первых натуральных чисел:
s = 1 + 2 + 3 + … + 98 + 99 + 100
Пусть s – искомая сумма,
i – очередное число (изменяется от 1 до 100).
Тогда алгоритм решения задачи можно описать следующим образом:
a. обнуляем сумму s = 0,
b. берем первое число: i = 1,
c. добавляем в сумму очередное число s = s + i,
d. как только очередное число станет больше ста, цикл заканчивает работу.
Представим этот алгоритм так:
s = 0;
i = 1;
ВЫПОЛНЯТЬ
s = s + i;
i = i + 1;
ПОКА (i <= 100);
Программа:
int i=1, s=0;
do
{
s+=i;
i++;
}
while (i <= 100);
System.out.printf(“/ns=%d i=%d”,s, i);
Результат решения задачи:
s=5050 i=101
Второй вариант решения задачи:
do
s+=i++;
while (i <= 100);
2. вычислить сумму s всех цифр заданного натурального числа n
Пусть s – искомая сумма,
i – очередная цифра числа.
Тогда алгоритм решения задачи можно описать следующим образом:
1. обнуляем сумму s = 0,
2. берем последнюю цифру числа, для чего определяем остаток от деления исходного числа на 10: i = n % 10,
3. добавляем в сумму найденную цифру: s = s + i,
4. уменьшаем число в 10 раз: n = n / 10,
5. повторяем цикл до тех пор, пока n!= 0.
Схема алгоритма:
Программа:
int i, n, s = 0;
String input;
input=JOptionPane.showInputDialog("Введите целое положительное число:");
n=Integer.parseInt(input);
do
{
i = n % 10;
s+=i;
n /= 10;
}
while (n!= 0);
System.out.printf(“/ns=%d”,s);
3. ввести с клавиатуры по одному последовательность целых чисел (конец последовательности – число 0). Определить их сумму, максимальное и минимальное число, количество введенных чисел и их среднее арифметическое.
Пусть s – искомая сумма,
min, max – минимальное и максимальное из введенных чисел,
count – количество введенных чисел,
sred – среднее арифметическое,
n – очередное число.
Тогда алгоритм решения задачи можно описать следующим образом:
a. обнуляем сумму s = 0,
b. вводим первое число n,
c. если оно не равно нулю, то
· принимаем его значение за min и max
· количество введенных чисел count = 1
· увеличиваем сумму на введенное число s = s + n
· входим в цикл ввода:
d. вводим очередное число n,
если оно не равно нулю, то
· количество введенных чисел увеличиваем на 1: count = count+1
· увеличиваем сумму на введенное число s = s + n
· если оно меньше min, то min = n,
· если оно больше max, то max = n,
e. повторяем цикл до тех пор, пока n # 0 – это и будет условием продолжения цикла.
Создадим интерфейс этой задачи – взаимодействие программы с пользователем, то есть что должно выводиться на экран:
Первое число: 3
Очередное число: 8
Очередное число: 1
Очередное число: -2
Очередное число: 0
Сумма = 10
Количество чисел = 4
min = -2
max = 8
Среднее арифметическое = 2.50
Программа
int min, max, n, count = 0;
double sred, s = 0.0;
String input;
input=JOptionPane.showInputDialog("Введите первое число:");
n=Integer.parseInt(input);
if (n==0) //если введено число 0, то
return 0; //выход из программы с результатом 0
//иначе
min = n; // за минимум и максимум принимаем
max = n; //первое введенное число
count = 1; //введено одно число
s += n; // в сумме – введенное число
do (n!=0)
{
input=JOptionPane.showInputDialog("Введите очередное число:");
n=Integer.parseInt(input);
if (n==0)
break;
count++;
s += n;
if (n > max)
max = n;
if (n < min)
min = n;
} while(n!=0);
System.out.printf(“\nСумма = %4.2f”, s);
System.out.printf(“\nКоличество чисел = %d”, count);
System.out.printf(“\nmin = %d”, min);
System.out.printf(“\nmax = %d”, max);
sred = (double)s/count;
System.out.printf(“\n Среднее арифметическое = %6.2f”,sred);
Схема алгоритма:
4. вычислить s – сумму членов бесконечного ряда:
s = 1 + x/ 1! + x2 / 2! + x3 / 3! + … + xk / k! + …
с погрешностью ε0.
Каждый последующий член ряда можно определить через предыдущий, используя рекуррентную формулу:
yk+1 = yk·x / k
Текущая погрешность вычислений ε определяется последним просуммированным членом ряда:
ε =|yn|
Эту погрешность необходимо сравнить с заданной погрешностью ε0 для реализации условия окончания суммирования:
- если ε > ε0, то заданная точность еще не достигнута, и суммирование ряда необходимо продолжить, прибавив к имеющейся сумме еще один член,
- если ε <= ε0, то заданная точность достигнута, и суммирование необходимо прекратить.
Пусть s – искомая сумма,
y – очередной член ряда,
k - номер члена ряда,
eps_0 – заданная точность вычислений,
x – вводимый аргумент.
Программа:
Public final double EPS_0 = 0.001;
int k = 0;
double x, y, s;
String input;
input=JOptionPane.showInputDialog("x=");
x=Double.parseDouble(input);
y = 1.0; // первый член ряда
s = y; // в сумме – он же
do
{
k++; // номер члена ряда увеличиваем на единицу
y *= x / k; // очередной член ряда
s += y; // добавляем его в сумму
}
while (Math.abs(y)>EPS_0);
System.out.printf(“\nСумма = %5.3f”, s);
Схема алгоритма:
Циклы с постусловием обычно используются в фильтрах входных данных – исходные данные вводятся до тех пор, пока они не будут корректными, а некорректные исходные данные отвергаются.
Пример: по введенному месяцу года определить количество дней в нем.
Схема фильтра (month – номер месяца)
Программа:
int month;
String input;
do
{
input=JOptionPane.showInputDialog("Введите номер месяца:");
month=Integer.parseInt(input);
} while ((month < 1) || (month > 12));
Switch (month)
{
case 1: case 3: case 5:
case 7: case 8: case 10:
case 12: System.out.printf(“\n31 день”);
break;
case 4: case 6: case 9:
case 11: System.out.printf(“\n30 дней”);
break;
case 2: System.out.printf(“\n28 дней”);
break;
default: System.out.printf(“\nТакого месяца нет\n”);
}
Циклы с пред - и пост условиями используются тогда, когда заранее неизвестно количество их повторений (итераций). Во всех остальных случаях используются циклы с параметром.
Циклы с параметром
Управление работой циклов с параметром осуществляется не только условием, но и значением специальной переменной – параметра цикла (счетчика).
Циклы этого типа получили наиболее широкое распространение в алгоритмических языках.
Схему цикла с параметром можно представить в следующем виде:
где x – параметр цикла – любая переменная,
x_нач – его начальное значение,
x_кон – его конечное значение,
x_шаг – шаг его изменения (не только целое число).
В Java циклы с параметром реализуются оператором цикла: