For (инициализация; условие; изменение)

{

оператор;

оператор;

оператор;

. . .

оператор;

}

где инициализация – устанавливает начальное значение параметра цикла,

условие – определяет условие выполнения цикла,

изменение – задает изменение параметра цикла после каждой итерации.

Действия цикла:

1. параметру цикла x присваивается его начальное значение x_нач,

2. проверяется условие выполнения цикла: если оно истинно, то выполняется тело цикла,

3. параметр цикла автоматически увеличивается на шаг, и цикл повторяется до тех пор, пока условие не становится ложным ,

4. если условие не выполняется, то цикл заканчивает работу,

5. из цикла можно выйти досрочно, используя оператор break.

Внимание! Все три составляющие в круглых скобках разделяются точками с запятой. После круглых скобок точка с запятой не ставится.

Пример: определить сумму s натуральных чисел от 1 до 100.

Схема алгоритма:

Программа:

int s = 0;

for (int n=1; n<=100; n++)// n – локальная переменная цикла

s+=n;

System.out.printf(“\ns=%d”, s);

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

Этот же цикл можно организовать без тела цикла:

for (int n=1; n<=100; s+=n++);

Эту же задачу можно решить, суммируя числа справа налево, то есть от 100 до 1:

for (int n=100; n>=1; s+=n--);

Любая из трех составляющих (инициализация, условии, изменение) может отсутствовать, причем если отсутствует условие продолжения цикла, то считается, что оно всегда истинно, и цикл превращается в бесконечный:

for (;;);

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

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

for (System.out.println(“Славное”); System.out.println(“море -”); System.out.println(“Байкал!”))

System.out.println(“священный”);

На экран будет выведена бесконечная последовательность:

Славное

Море -

Священный

Байкал!

Море -

Священный

Байкал!

Море -

Священный

Байкал!

. . . . .

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

for (int count=0; getch()!=’\n’; count++);

Этот цикл подсчитывает количество вводимых с клавиатуры символов, пока не будет нажата клавиша ввода (она соответствует ESC-последовательности ‘\n’). В этом цикле параметр цикла count не входит в условие его выполнения - это тоже не обязательно.

В одном цикле for можно использовать одновременно несколько параметров цикла, которые при инициализации разделяются запятыми:

for (int i=0, int j=n; i<j; i++, j--)

{

. . . . .

}

Как и в других языках программирования, в Java разрешено использовать цикл в цикле, при этом циклы должны иметь разные параметры цикла:

int sum, min=6, max=10000;

System.out.printf(“\nСовершенные числа от %d до %d:\n”, min, max);

for (int num = min; num <= max; num += 2)

{

sum = 1;

for (int factor = 2; factor < num; factor++)

{

if (num % factor == 0)

sum += factor;

}

if (sum == num)

System.out.printf(“\n%d”, num);

}

Эта программа осуществляет поиск всех совершенных чисел от 6 до 10000.

Для досрочного прекращения выполнения цикла и выхода из него используется оператор прерывания break:

public final int MIN=2;

public final int MAX=1000;

for (int n = MIN; n <= MAX; n++)

{

for (int i = MIN; i < n; i++)

{

if (n % i == 0)

break; //выход из внутреннего цикла

}

if (i == n)

System.out.printf(“\n%d”, n);

}

}

Эта программа осуществляет поиск всех простых чисел от 2 до 1000.

Во вложенных циклах команда break прекращает выполнение только того цикла, в котором стоит.

Для пропуска одной итерации цикла (перехода к следующей итерации) используется команда продолжения continue:

public final int MIN=3;

public final int MAX=100;

for (int number = MIN; number <= MAX; number++)

{

if (number % 3 != 0)

continue; // следующая итерация цикла

System.out.printf(“\n%d”, number);

}

Эта программа осуществляет поиск всех чисел, кратныхтрем, от 3 до 100.

Примеры:

1. Вычислить S_n – сумму n первых натуральных чисел

Алгоритм:
S_n = 0

Для i от 1 до n выполнять

S_n = S_n + i

Программа:

int n, sn=0;

String input;

input=JOptionPane.showInputDialog("До какого числа суммировать:");

n=Integer.parseInt(input);

for (int i = 1; i <= n; i++)

sn+=i;

System.out.printf(“\nСумма чисел от 1 до %d равна %d ”, n, sn);

Операторы прерывания break, continue, return, System.exit

Часто требуется прерывать цикл или выполнение функции при выполнении некоторых условий и перейти на выполнение другого алгоритма или очередной итерации цикла. В Java имеются гибкие структурные средства для решения подобных проблем – это операторы break, continue, return, System.exit:

continue прерывание выполнения тела цикла и переход к следующей итерации текущего цикла,

continue меткапрерывание выполнения тела цикла и переход к следующей итерации цикла, помеченного меткой,

break выход из текущего цикла,

break меткавыход из цикла, помеченного меткой,

return выход из текущей функции (в том числе из тела цикла) без возвратазначения,

return значениевыход из текущей функции (в том числе из тела цикла) с возвратомзначения,

System.exit(n) выход из приложения с кодом завершенияn – целым числом, задаваемым программистом (n=0 – выход нормальный, в остальных случаях – аварийный). Перед своим завершением приложение сообщает операционной системе код завершения, чтобы программист смог установить, по какой причине произошел аварийный выход,

меткаидентификатор (имя), после которого ставится двоеточие. Метка может располагаться перед любым оператором. В этом случае оператор называется помеченным:

label_1: // метка

for (int i=1; i<=4; i++)

for (int j=1; j<=4; j++)

{

if (i==j)

continue label_1; // переход на метку label_1

System.out.println(“i=” + i + “ j=” +j);

}

В окне вывода появится:

i=2 j=1

i=3 j=1

i=3 j=2

i=4 j=1

i=4 j=2

i=4 j=3

При выполнении условия (i==j) внутренний цикл прерывается, и управление передается внешнему циклу – берется следующее значение i, а внутренний цикл сбрасывается на j=1.

label_1:

for (int i=1; i<=4; i++)

for (int j=1; j<=4; j++)

{

if (i!=j)

break label_1; // переход на метку label_1

System.out.println(“i=” + i + “ j=” +j);

}

В окне вывода появится:

i=1 j=1

При первом же выполнении условия (i!=j) прерывается цикл, перед которым стоит метка label_1, то есть внешний цикл, и программа заканчивает работу.

for (int i=1; i<=4; i++)

{

label_1:

for (int j=1; j<=4; j++)

{

if (i==j)

break label_1;

System.out.println(“i=” + i + “ j=” +j);

}

}

В окне вывода появится:

i=2 j=1

i=3 j=1

i=3 j=2

i=4 j=1

i=4 j=2

i=4 j=3

При первом же выполнении условия (i==j) прерывается цикл, перед которым стоит метка label_1, то есть внутренний цикл , и управление передается внешнему циклу – берется следующее значение i, а внутренний цикл сбрасывается на j=1. Такой же результат получается, если совсем убрать метку label_1 перед внутренним циклом:

for (int i=1; i<=4; i++)

for (int j=1; j<=4; j++)

{

if (i==j)

break;

System.out.println(“i=” + i + “ j=” +j);

}

Структуры данных

В повседневной практике обработки информации мы часто имеем дело с естественно организованными (объединенными) представлениями информации: текстами, списками, таблицами, анкетами. Такие организованные (структурированные) данные во многом облегчают их восприятие и обработку.

Естественная организация данных эффективно отражается в современных языках программирования понятием структур данных.

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

Отличительной особенность хорошо написанных программ является то, что данные в них организованы в определенные, наиболее подходящие для их хранения и обработки структуры, а сами программы являются лишь средством обработки этих структур независимо от их информационного содержания. Проектирование подходящих структур данных для их эффективной обработки программой столь же важно, и занятие это, возможно, более сложное, чем написание собственно операторов программы в соответствии с выбранным алгоритмом их обработки. Хорошо спроектированные структуры данных облегчают и ускоряют их обработку, улучшают понимание самой программы. Организация структур данных и их взаимодействия в объектно-ориентированном программировании занимает 95% объема времени написания программы.

К базовым структурам данных в Java относятся:

- переменные,

- массивы,

- строки,

- файлы.

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

Массивы

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

int pi_11_1, pi_11_2, pi_11_3, pi_11_4… pi_11_25;

Каждая из них будет соответствовать оценке одного студента. После этого используем 25 операторов для ввода оценок:

input=JOptionPane.showInputDialog("Введите оценку первого:");

pi_11_1=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Введите оценку второго:");

pi_11_2=Integer.parseInt(input);

. . .

input=JOptionPane.showInputDialog("Введите оценку 25-го:");

pi_11_25=Integer.parseInt(input);

И, наконец, определим средний балл:

double sr_ball;

sr_ball=(pi_11_1+pi_11_2+pi_11_3+ . . . +pi_11_25)/25.0;

А что произойдет, если нужно будет решить эту задачу для всего университета? Описать и вводить несколько тысяч переменных?

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

Массив состоит из конечного числа элементов (компонент), содержимое которых относится к некоторому общему, базовому типу. При этом сам базовый тип должен быть таким, что принадлежность к нему гарантирует одинаковые размеры памяти для размещения каждой из компонент. Элементы различаются местом их размещения внутри структуры, иначе говоря, номером или индексом. Обычным является непрерывное представление массива, как логическое, так и физическое, то есть логический (описанный в программе) массив проецируется на непрерывный участок оперативной памяти. Значит, необходимо, чтобы такой участок существовал. Отсюда вытекают ограничения на размер массива, диктуемые организацией оперативной памяти: массив должен поместиться в сегмент данных программы, размеры которого фиксированы. И, конечно, данные в массивах сохраняются только до конца работы программы.

Таким образом, массив представляет собой структуру данных, определяемую на основе следующих своих свойств:

1. массив состоит из однотипных элементов, при этом используемый тип называется базовым,

2. число элементов массива строго фиксировано,

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

4. количество индексов, которое связано с отдельным элементом массива, определяет его размерность (одномерные, двумерные, трехмерные …),

5. число элементов массива совпадает с общим количеством возможных значений его индексов,

6. массив – именованная совокупность данных, причем использование его имени совместно с индексами позволяет определять значения его элементов,

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

Массивы можно определить и через понятия математики.

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

МатрицейA_nm называется таблица чисел, состоящая из n строк и m столбцов.

Каждый элемент матрицы a_ij полностью определяется своими индексами – номерами строки i и столбца j , в которых он расположен.

Количество индексов определяет размерность матрицы: одномерная (вектор), двумерная, трехмерная и т.д.

Максимальное значение каждого индекса определяет размер матрицы.

В качестве аналога матриц в программировании выступают массивы.

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

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

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

a₁₁ a₁₂ a₁₃ …

a₂₁ a₂₂ a₂₃ …

a₃₁ a₃₂ a₃₃ …

……………………..

Таким образом, двумерный массив полностью соответствует понятию матрицы. В оперативной памяти элементы двумерного массива расположены последовательно, строка за строкой: сначала элементы первой строки, затем второй и так далее: a₁₁, a₁₂, a₁₃,…, a₂₁, a₂₂, a₂₃,…, a₃₁, a₃₂, a₃₃,… Значит, быстрее изменяется второй индекс (номер столбца), чем первый (номер строки).

Многомерные массивы располагаются в памяти компьютера так, что сначала изменяется последний индекс элемента, затем – предпоследний и так далее.

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

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

Индексы элементов массива могут быть только целыми положительными числами и начинаются с нуля.

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

- при компиляции программы, то есть до запуска ее на выполнение,

- непосредственно при выполнении программы.

В первом случае говорят о статическом распределении памяти. Если память выделяется в процессе выполнения программы, говорят о динамическом распределении памяти.

В Java память для массивов, строк и объектов выделяется непосредственно в процессе выполнения программы, то есть динамически.

Создание массива в Java подразумевает реализацию двух этапов:

1. объявление (declaration) переменой массива (ссылки), указывающей, где в памяти компьютера он расположен:

int myArray[]; // квадратные скобки после имени!

объявлена переменная массива myArray - ссылка на массив целого типа,

2. создание непосредственно массива – выделение в памяти места для хранения его элементов оператором new и связывание его со ссылкой на массив:

myArray=new int[10];

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

Как правило, эти две операции объединяются в одну:

int myArray[]=new int[10];

Размер массива можно задавать целым числом при его описании, а также переменной или константой целого типа. Значение этой переменной можно задать оператором присваивания или ввести с клавиатуры:

int n=10;

int myArray[]=new int[n];

или

public final int RAZMER=10;

int myArray[]=new int[RAZMER];

или

int n;

String input;

input=JOptionPane.showInputDialog("Задайте размер массива:");

n=Integer.parseInt(input);

int myArray[]=new int[n];

Индексация элементов массивов в Java, как и в Си, начинается с нуля. Поэтому последний элемент массива будет иметь индекс на единицу меньше его размера. Размер массива можно определить через свойство length:

n=myArray.length; // n – количество элементов в массиве

В отличие от Си, в Java выполняется автоматическая проверка выхода за пределы массива – это повышает надежность программы.

В Java можно создавать не только одномерные массивы (векторы), но и двухмерные (матрицы), трехмерные (кубы) и так далее. В этом случае количество индексов элементов определяет размерность массива: одномерные, двумерные, трехмерные…

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

double matrica[][]=new double [3][5];

Описан двумерный массив matrica, состоящий из трех строк и пяти столбцов. Нумерация строк от 0 до 2, столбцов – от 0 до 4.

Как видно, при описании массива в Java каждая его размерность записывается в отдельных скобках, а не перечисляется через запятые, как в Паскале.

Элементы массива можно использовать во всех выражениях, операторах и функциях, определенных для их типа.

Начальные значения элементам массива в Java можно задавать при их описании (инициализировать массив), при этом размеры массивов в квадратных скобках можно не указывать – для их хранения будет отведено столько ячеек оперативной памяти, сколько значений указано в фигурных скобках:

int vect[] = new int[]{-5, 3, -2, 8, 1}; //5 элементов

double matr[][] = new double[][]{{0.2, -1.5, 3.14},

{-2.73, 25.54, 0.89}}; //2 строки и 3 столбца

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

matr[1][2]=0.89;

Для вывода элементов одномерного массива (вектора) на экран используется специальная форма цикла for:

for (тип_массива переменная: имя_массива)

{

Операторы вывода

}

Например, необходимо вывести на экран элементы следующего массива:

int myVector[]=new int[10]{9,8,7,6,5,4,3,2,1,0};

Используем специальную форму цикла for:

For (int value: myVector)

System.out.printf(“%5d”, value);

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

В окне вывода появится:

9 8 7 6 5 4 3 2 1 0

Примеры:

1. задать с помощью генератора случайных чисел элементы целочисленного массива matr₃₄, вывести его на экран и в диалоговое окно вывода построчно. Размеры массива ввести с помощью диалогового окна ввода:

package javaapplication1;

// импорт библиотеки графических компонентов Swing

import javax.swing.*;

import java.util.*;

public class JavaApplication1 // задание главного класса программы

{

// описание главного метода main этого класса

public static void main(String[] args)

{

//описание переменных:

int n, m, matrMin, matrMax;

String input, text;

// вызов диалогового окна ввода исходных данных

input=JOptionPane.showInputDialog("Нижняя граница диапазона matrMin:");

// преобразование из строкового значения в целое

matrMin=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Верхняя граница диапазона matrMax:");

matrMax=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Количество строк n:");

n=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Количество столбцов m:");

m=Integer.parseInt(input);

// формирование строки вывода

text="Значения входных переменных:\nmatrMin=" + matrMin + "\nmatrMax=" + matrMax + "\nn=" + n + "\nm=" + m;

// вызов диалогового окна эхо-печати

JOptionPane.showMessageDialog(null, text);

//консольный вывод

System.out.printf("matrMin=%d\nmatrMax=%d\nn=%d\nm=%d\n ",

matrMin, matrMax, n, m);

// создание матрицы n x m элементов

int matr[][]=new int[n][m];

//консольный вывод

System.out.println("Исходная матрица:");

/*

создание объекта Rand класса Random - генератора случ. чисел

инициализация генератора случайных чисел,

привязка его к системному времени

*/

Random Rand=new Random();

// заполнение матрицы случайными числами

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

{

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

{

// получение очередного случайного числа в диапазоне

// от matrMin до matrMax

matr[i][j]=Rand.nextInt(matrMax-matrMin+1) + matrMin;

//консольный вывод элементов матрицы построчно

System.out.printf(" %5d", matr[i][j]);

}

//переход на новую строку

System.out.println();

}

//вывод элементов матрицы в диалоговое окно

text="Исходная матрица:\n";

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

{

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

text+=matr[i][j] + " ";

text+=”\n”; //переход на новую строку

}

// вызов диалогового окна

JOptionPane.showMessageDialog(null, text);

}

}

В окне вывода появится:

matrMin=-10

matrMax=10

n=3

m=4

Исходная матрица:

10 8 2 6

3 10 -1 -6

-3 -6 -8 7

2. Рассортировать элементы заданного случайным образом целочисленного вектора vector[n] методом обменной сортировки (пузырька):

package javaapplication6_1;

// импорт библиотеки графических компонентов Swing

import javax.swing.*;

import java.util.*;

public class JavaApplication6_1 // задание главного класса

{

// описание главного метода main этого класса

public static void main(String[] args)

{

//описание переменных:

int n, vectorMin, vectorMax, temp;

String input, text;

// вызов диалогового окна ввода исходных данных

input=JOptionPane.showInputDialog("Нижняя граница диапазона vectorMin:");

// преобразование из строкового значения в целое

vectorMin=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Верхняя граница диапазона vectoMax:");

vectorMax=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Размер вектора n:");

n=Integer.parseInt(input);

// формирование строки вывода

text="Значения входных переменных:\nvectorMin=" + vectorMin +

"\nvectorMax=" + vectorMax + "\nn=" + n;

// вызов диалогового окна эхо-печати

JOptionPane.showMessageDialog(null, text);

//консольный вывод

System.out.printf("vectorMin=%d\nvectorMax=%d\nn=%d\n",

vectorMin, vectorMax, n);

// создание вектора длиной n элементов

int vector[]=new int[n];

//консольный вывод

System.out.println("Исходный вектор:");

/*

создание объекта Rand класса Random - генератора случ.чисел

инициализация генератора случайных чисел,

привязка его к системному времени

*/

Random Rand=new Random();

// создание вектора случайных чисел

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

{

// получение очередного случайного числа в диапазоне

// от vectorMin до vectorMax

vector[i]=Rand.nextInt(vectorMax-vectorMin+1) + vectorMin;

//консольный вывод элемента вектора

System.out.printf(" %5d", vector[i]);

}

System.out.println();

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

for (int j=n-2; j>=0; j--)

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

if (vector[i] > vector[i+1])

{

temp=vector[i];

vector[i]=vector[i+1];

vector[i+1]=temp;

}

System.out.println("Отсортированный вектор:");

//консольный вывод вектора

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

System.out.printf(" %5d", vector[i]);

System.out.println();

}

}

В окне вывода появится:

vectorMin=-10

vectorMax=10

n=10

Исходный вектор:

10 -7 -1 3 -6 7 7 -1 9 -2

Отсортированный вектор:

-7 -6 -2 -1 -1 3 7 7 9 10

3. Рассортировать элементы заданного случайным образом целочисленного вектора vector[n] методом Шелла (обменная сортировка с убывающим шагом). В этом случае массив делится на группы по два элемента и производится сортировка в каждой группе: максимальный элемент ставится на второе место. После этого массив делится на группы по четыре элемента, и они снова сортируются. Количество элементов в сортируемой группе удваивается до тех пор, пока не остается одна группа, включающая все элементы массива, которая и сортируется окончательно:

package javaapplication6_1;

// импорт библиотеки графических компонентов Swing

import javax.swing.*;

import java.util.*;

public class JavaApplication6_1 // задание главного класса

{

// описание главного метода main этого класса

public static void main(String[] args)

{

//описание переменных:

int n, vectorMin, vectorMax, temp;

int i1, i2, i3, m, per;

String input, text;

// вызов диалогового окна ввода исходных данных

input=JOptionPane.showInputDialog("Нижняя граница диапазона vectorMin:");

// преобразование из строкового значения в целое

vectorMin=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Верхняя граница диапазона vectoMax:");

vectorMax=Integer.parseInt(input);

input=JOptionPane.showInputDialog("Размер вектора n:");

n=Integer.parseInt(input);

// формирование строки вывода

text="Значения входных переменных:\nvectorMin=" + vectorMin +

"\nvectorMax=" + vectorMax + "\nn=" + n;

// вызов диалогового окна эхо-печати

JOptionPane.showMessageDialog(null, text);

//консольный вывод

System.out.printf("vectorMin=%d\nvectorMax=%d\nn=%d\n",

vectorMin, vectorMax, n);

// создание вектора длиной n элементов

int vector[]=new int[n];

//консольный вывод

System.out.println("Исходный вектор:");

/*

создание объекта Rand класса Random - генератора случ.чисел

инициализация генератора случайных чисел,

привязка его к системному времени

*/

Random Rand=new Random();

// формирование вектора

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

{

// получение очередного случайного числа в диапазоне

// от vectorMin до vectorMax

vector[i]=Rand.nextInt(vectorMax-vectorMin+1) + vectorMin

//консольный вывод элемента вектора

System.out.printf(" %5d", vector[i]);

}

System.out.println();

// сортировка вектора методом Шелла

i1=n-1;

while (i1>=1)

{

i1 /= 2;

i2=n-i1-1;

do

{

per=1;

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

{

i3=i+i1;

if (vector[i] > vector[i3])

{

temp=vector[i];

vector[i]=vector[i3];

vector[i3]=temp;

per=0;

} // if (vector[i] > vector[i3])

} // for (i=0; i<=i2; i++)

}while (per==0); // do

} // while (i1>=1)

System.out.println("Отсортированный вектор:");

//консольный вывод вектора

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

System.out.printf(" %5d", vector[i]);

System.out.println();

}

}

В окне вывода появится:

vectorMin=-10

vectorMax=10

n=10

Исходный вектор:

1 -1 2 8 6 0 -9 9 -5 4

Отсортированный вектор:

-9 -5 -1 0 1 2 4 6 8 9