Заведём джаву. Внеурочная заметка №2. Сортировка чисел по возрастанию.

ЗАМЕТКА НЕДООФОРМЛЕНА. ЧУТЬ ПОЗЖЕ ИЗМЕНЮ.

 

Интересно задание и элегантное решение удалось обнаружить на просторах сети по Java. Считаю целесообразным опубликовать его здесь и разобрать по строкам. Суть задания: пользователь вводит 5 чисел и программка выводит их по мере возрастания. Код:


public class array {

    public static void main(String[] args) throws Exception
    {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int[] a = new int[5];
        for (int i = 0; i < 5; i++){
            a[i] = Integer.parseInt(reader.readLine());
        }

        for (int i = 0; i < a.length; i++){
            int min = a[i];
            int minIndex = i;
            for (int j = i + 1; j < a.length; j++){
                if (a[j] < min){
                    min = a[j];
                    minIndex = j;
                }
            }
            if (i != minIndex){
                int temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
            }
            System.out.println(a[i]);
        }
    }
}


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

Объявляется так: тип[] имя;
тип имя[];

Где тип — это тип элементов массива, а имя — уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы.

Пример: String[] kotiki = new String[5]; Мы объявили массив kotiki типа String (строка), который будет содержать 5 значений.

Пример:


String[] kotiki = new String[5];

kotiki[0] = "Пусь";

kotiki[1] = "Мурчик";

kotiki[2] = "Барсик";

kotiki[3] = "Мурзик";

kotiki[4] = "Китякет";

System.out.println(kotiki[2]);

Обращение к элементу массива происходит так — имя массива и в квадратных скобках порядковый номер элемента. Так вышеприведённый код выведет значение «Барсик» на экран ( System.out.println(kotiki[2]) )

Обратите внимание, что нумерация значений массива начинается ноля! Однако, если добавить вот такую строку:

System.out.println(kotiki.length);

то увидим, что система нам выдаст число «5». Метод length() возвращает длину строки, в нашем случае количество элементов в массиве. Следует обратить внимание на то, что индекс значения массива мы считаем с числа ноль, однако метод «ведёт отсчёт» с единицы.

Внутри метода main строка


BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));



является более короткой записью кода из предыдущей &amp;amp;amp;lt;strong&amp;amp;amp;gt;&amp;amp;amp;lt;a href="http://makson.ru/zavedyom-dzhavu-vneurochnaya-zametka-1/"&amp;amp;amp;gt;внеурочной заметке&amp;amp;amp;lt;/a&amp;amp;amp;gt;&amp;amp;amp;lt;/strong&amp;amp;amp;gt;.

сравните



InputStream inputStream = System.in;
Reader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

Напоминаю для ввода данных используется System.in. Но System.in позволяет считать с клавиатуры только коды символов. Чтобы считать строку с клавиатуры, можно использовать объект BufferedReader. Но для этого в него нужно передать объект, из которого он будет вычитывать данные – System.in.

Однако System.in и BufferedReader не совместимы друг с другом, поэтому следует использовать переходник – еще один объект InputStreamReader.

Строка

int[] a = new int[5];

— создаёт массив типа Int (целочисленные числа), состоящий из 5 элементов.

  for (int i = 0; i &amp;amp;amp;lt; 5; i++){
            a[i] = Integer.parseInt(reader.readLine());
        }

— цикл for, состоящий из 5 итераций. При каждой итерации элемент массива «a» получает значение, введённое с клавиатуры.

 reader.readLine() 

— считывает строку, а

 Integer.parseInt 

преобразовывает строку число.

В результате чего мы должны будем 5 раз ввести числа с клавиатуры для заполнения массива «a,» состоящего из 5 элементов.

Далее у нас идёт цикл в цикле. Разберём его.



 for (int i = 0; i &amp;amp;amp;lt; a.length; i++){            
            int min = a[i]; 
            int minIndex = i; 
            for (int j = i + 1; j &amp;amp;amp;lt; a.length; j++){              
                if (a[j] &amp;amp;amp;lt; min){
                    min = a[j];
                    minIndex = j;
                }
            }
            if (i != minIndex){
                int temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
            }
            System.out.println(a[i]);
        }

Разберём на примере. Допустим мы ввели следующие числа: 6 4 8 3 5, что же произойдёт?

a[0] = 6;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;

Как мы видим у нас есть цикл в цикле. Для удобство будем обозначать их так 1-1, 1-2, 1-3 и т.д…

 

Итерация 1-1.

Начало первой итерации. Переменная i равна 0. Цикл работает пока i меньше a.length. Метод length считает количество элементов массива. Считает, начиная с 1, а не с 0! Стало быть a.length равно 5.  Ну и конечно же i увеличивается на 1, иначе цикл станет бесконечным.

переменная min равна a[i]. Если i у нас 0, значит a[0]. А это у нас число 6 из введённого массива. Стало быть на данном этапе переменная min равна 6.

minIndex равно 0 соответственно. Начинается внутренняя итерация, в которой переменная j равна i плюс один. Соответственно j равно 0 + 1, то есть j = 1.

Условный цикл выполняется в данном случае. a[j] это a[1], то есть второй элемент массива, имеющий значение 4. 4 меньше 6. А стало быть переменная min равна a[j], то есть a[1], стало быть min вместо 6 теперь равна 4! А minIndex равен j, а значит единице, вместо 0!

 

 

 

 

 

 

 

 

 

 

 

Обратите внимание, что изменилось значение переменных выше второго цикла.

 


int min = a[i]; // min : 4 (а было min : 6)

int minIndex = i; // minIndex : 1 (а было minIndex: 0).

Итерация 1-2.

 

 

 

 

 

 

 

 

 

 

 

 

 

j = 2.

a [j] = a[2] = 8. Восемь не меньше переменной min, поскольку min = 4. Стало быть условный цикл не выполнится и мы переходим к итерации 1-3.

 

Итерация 1-3.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

j = 3. a[j] = a[3]. Стало быть a[3] рано 3. min = 4, стало быть условный цикл выполняется —  3 меньше 4.

min = a[j], стало быть min = a[3] = 3.

minIndex также равен 3 (индекс массива у нас ведь тоже 3).

 

 

 

 

 

 

 

 

 

 

 

 

Итерация 1-4.

 

 

 

 

 

 

 

 

 

 

 

 

j = 4.  a[j] = a[4] = 5. min = 3. 5 не меньше 3, стало быть условный цикл не выполнится и мы переходим к следующему блоку кода.

 


if (i != minIndex){
    int temp = a[i];
    a[i] = a[minIndex];
    a[minIndex] = temp;
}
System.out.println(a[i]);

i = 0; Почему 0? Да потому что эта переменная i относится к первому циклу for! minIndex = 3.
0 не равно 3, стало быть условие выполнится.

int temp = a[i] = a[0] = 6;

a[i] = a [minIndex] то есть a[0] = a[3]

то есть a[0] = 3!

a[minIndex] = temp, то есть a[3] = 6.

 

 

 

 

 

 

 

 

 

 

 

System.out.println(a[i]) = System.out.println(a[3]); = System.out.println(3);

То есть первое число, которое покажет программа - 3, наименьшее.

Теперь обратите внимание вот на что: благодаря конструкции 

 int temp = a[i];
 a[i] = a[minIndex];
 a[minIndex] = temp;

a[3] равно 6 [temp], а стало быть в массиве int[] a = new int[5]; произошли изменения. Было:

 

a[0] = 6;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;

Но теперь a[i] = a[minIndex], то есть a[0] = a[3]; А значит теперь массив выглядит так:

a[0] = 3;
a[1] = 4;
a[2] = 8;
a[3] = 3;
a[4] = 5;

Смотрим дальше

 a[minIndex] = temp; то есть  a[3] = 6 (ведь int temp = a[i] то есть int temp = 6!). И картина выглядит так: 

a[0] = 3;
 a[1] = 4;
 a[2] = 8;
 a[3] = 6;
 a[4] = 5;

 




















Переходим к циклу 2!


i = 1;
























int min = a[i]; => int min = a[1] => int min => 4;

int minIndex = i; => int minIndex = 1;  

























Переходим к внутреннему циклу. 

Итерация 2-1. 

int j = i + 1; j < a.length; j++ => int j = 1 + 1; j < 5; j = 2 + 1;

Условие не выполняется! a[j] < min => a[2] < min => a[2] = 8 < min = 4 => 8 < 4 

8 никак не может быть меньше 4, значит условие не выполнится! Понятно, почему 8? Напоминаю, массив считают с 0! 

Итерация 2-2. 

int j = 3; j < 5; j = 3 + 1;

a[j] < min => a[3] < min => a[3] = 6 < min = 4 => 6 < 4 

6 никак не может быть меньше 4, значит условие не выполнится!


 

 

 

 

 

 

 

 

 

 

Итерация 2-3

int j = 4; j < 5; j = 4 + 1;

a[j] < min => a[4] < min => a[4] = 5 < min = 4 => 5 < 4 

5 никак не может быть меньше 4, значит условие не выполнится!

 

 

 

 

 

 

 

 

 

 

 

 

 

Теперь переходим к следующему блоку

 

&amp;lt;pre&amp;gt;if (i != minIndex){
    int temp = a[i];
    a[i] = a[minIndex];
    a[minIndex] = temp;
}
System.out.println(a[i]);&amp;lt;/pre&amp;gt;
&amp;amp;nbsp;

 

А чему у нас равно i в первом цикле? Правильно i = 1. А чему равен minIndex? Точно тоже 1. А стало быть условный цикл не выполнится! И нам останется только вывести на экран a[i], то есть a[1] = 4!

Итерация 3.

 

 

 

 

 

 

 

 

 

 

 

 

 

int min = a[i]; => int min = a[2] => int min => 8;

int minIndex = i; => int minIndex = 2;

 

Переходим к внутреннему циклу. 

Итерация 3-1. 

int j = i + 1; j < a.length; j++ => int j = 2 + 1; j < 5; j = 3 + 1;
a[j] < min => a[3] < min => a[3] = 6 < min = 8 => 6 < 8

Условный цикл выполняется!




 

 

 

 

 

 

 

 

 

 

 

min = a[3]; => min = 6;

minIndex = 3;

Итерация 3-2.

 

int j = i + 1; j < a.length; j++ => int j = 4; j < 5; j = 4 + 1;
a[j] < min => a[4] < min => a[4] = 5 < min = 6 => 5 < 6; Условие выполняется!

min = a[4]; => min = 5;

minIndex = 4; 

Далее переходим к условному циклу, поскольку итерации закончились - пять не меньше a.length, которое, собственно и равно пяти. 

i = 2; minIndex = 4;

Так что условный цикл выполняется. 

int temp = a[i]; => int temp = a[2]; => int temp = 8;

a[i] = a[minIndex]; => a[2] = a[4]; => a[2] = 5;
a[minIndex] = temp; => a[4] = temp; a[4] = 8;























Осталось только вывести на экран.
System.out.println(a[2]); То есть цифра 5.
Обратите внимание, как изменились значения массива! 

 

 

 

 

 

 

 

 

 

 

 

 

 

Итерация 4.

 

 

 

 

 

 

 

 

 

 

 

 

 

i = 3;

int min = a[i]; => int min = a[3]; => int min = 6;

int minIndex = 3;

Переходим к внутренней итерации.

Итерация 4-1.

int j = i + 1; j < a.length; j++ => int j = 3 + 1; j < 5; j = 4 + 1;
a[j] < min => a[4] < min => a[4] = 8 < min = 6 => 8 < 6

Не выполняется! 8 не меньше 6. 

Внутренние итерации закончились! Переходим к условному циклу. 

</pre><pre>if (i != minIndex){
    int temp = a[i];
    a[i] = a[minIndex];
    a[minIndex] = temp;
}
System.out.println(a[i]);

i = 3;

minIndex = 3; Значит условный цикл не выполняется! Осталось просто вывести на экран число.
System.out.println(a[i]); => System.out.println(a[3]); => System.out.println(6);



 

 

 

 

 

 

 

 

 

Итерация 5.

i = 4;

int min = a[i]; => int min = a[4]; => int min = 8;

int minIndex = 4;

 

 

 

 

 

 

 

 

 

 

 

 

 

Итерация 5-1.

int j = i + 1; j < a.length; j++ => int j = 4 + 1; j < 5; j = 5 + 1; Как бы так, да вот и не так. 
Не один цикл не выполнится, поскольку 5 не можеть быть меньше 5. Переходим к условному циклу. 























i = 4; minIndex = 4; Стало быть условный цикл не выполнится. Осталось вывести число на экран.
System.out.println(a[i]); => System.out.println(a[4]); => System.out.println(8);

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

 

 

 

 

 

 

 

 

 

 

Вы можете следить за ответами к этой записи через RSS 2.0 ленту.Вы можете оставить ответ, или архив с вашего сайта.

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *