Массив это структура данных, представленная в виде группы ячеек одного типа, объединенных под одним единым именем. Массивы используются для обработки большого количества однотипных данных. Имя массива является , что такое указатели расскажу немного позже. Отдельная ячейка данных массива называется элементом массива. Элементами массива могут быть данные любого типа. Массивы могут иметь как одно, так и более одного измерений. В зависимости от количества измерений массивы делятся на одномерные массивы, двумерные массивы, трёхмерные массивы и так далее до n-мерного массива. Чаще всего в программировании используются одномерные и двумерные массивы, поэтому мы рассмотрим только эти массивы.
Одномерные массивы в С++
Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива. На рисунке 1 показана структура целочисленного одномерного массива a . Размер этого массива — 16 ячеек.
Рисунок 1 — Массивы в С++
Заметьте, что максимальный индекс одномерного массива a равен 15, но размер массива 16 ячеек, потому что нумерация ячеек массива всегда начинается с 0. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).
//синтаксис объявления одномерного массива в С++: /*тип данных*/ /*имя одномерного массива*/; //пример объявления одномерного массива, изображенного на рисунке 1: int a;
где, int —целочисленный ;
А — имя одномерного массива;
16 — размер одномерного массива, 16 ячеек.
Всегда сразу после имени массива идут квадратные скобочки, в которых задаётся размер одномерного массива, этим массив и отличается от всех остальных переменных.
//ещё один способ объявления одномерных массивов int mas, a;
Объявлены два одномерных массива mas и а размерами 10 и 16 соответственно. Причём в таком способе объявления все массивы будут иметь одинаковый тип данных, в нашем случае — int .
// массивы могут быть инициализированы при объявлении: int a = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // инициализация одномерного массива
Инициализация одномерного массива выполняется в фигурных скобках после знака равно , каждый элемент массива отделяется от предыдущего запятой.
Int a={5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15}; // инициализации массива без определения его размера.
В данном случае компилятор сам определит размер одномерного массива. Размер массива можно не указывать только при его инициализации, при обычном объявлении массива обязательно нужно указывать размер массива. Разработаем простую программу на обработку одномерного массива.
// array.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// array.cpp: определяет точку входа для консольного приложения.
#include
В строках 10 — 11 объявлен и проинициализирован целочисленный одномерный массив с именем array1 , размер которого равен 16 ячейкам, то есть такой массив может хранить 16 чисел. Любая обработка массива осуществима только совместно с циклами. Какой цикл выбрать для обработки массива — это вам решать. Но лучше всего для этой задачи подходит . Переменную-счётчик counter будем использовать для обращения к элементам одномерного массива array1 . В условии продолжения цикла for стоит строгий знак неравенства, так как шестнадцатого индекса в одномерном массиве array1 нет. А так как нумерация ячеек начинается с нуля, то элементов в массиве 16. В теле цикла for оператор cout печатает элементы одномерного массива (см. Рисунок 2).
Obrabotka massiva indeks element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Для продолжения нажмите любую клавишу. . .
Рисунок 2 — Массивы в С++
Разработаем ещё одну программу на обработку одномерного массива в С++. Программа должна последовательно считывать десять введённых чисел с клавиатуры. Все введённые числа просуммировать, результат вывести на экран.
// array_sum.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// array_sum.cpp: определяет точку входа для консольного приложения.
#include
Перед тем как выполнять обработку массива его необходимо объявить, причём размер одномерного массива равен 10, так как это оговорено условием задачи. В переменной sum будем накапливать сумму элементов одномерного массива. Первый цикл for заполняет объявленный одномерный массив, введёнными с клавиатуры числами, строки 12 — 13 . Переменная счётчик counter используется для последовательного доступа к элементам одномерного массива array1 , начиная с индекса 0 и до 9-го включительно. Второй цикл for выводит на экран элементы массива, строки 15 — 16 . Третий цикл for последовательно считывает элементы одномерного массива и суммирует их, сумма накапливается в переменной sum , строки 17 — 18 . Результат работы программы смотреть на рисунке 3.
Enter elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 = {0 1 2 3 4 5 6 7 8 9 } sum = 45 Для продолжения нажмите любую клавишу. . .
Рисунок 3 — Массивы в С++
Сначала последовательно были введены все 10 чисел, после чего отобразился одномерный массив, и напечаталась сумма чисел массива.
Двумерные массивы в С++
До этого момента мы рассматривали одномерные массивы, которыми не всегда можно ограничиться. Допустим, необходимо обработать некоторые данные из таблицы. В таблице есть две характеристики: количество строк и количество столбцов. Также и в двумерном массиве, кроме количества элементов массива, есть такие характеристики как, количество строк и количество столбцов двумерного массива. То есть, визуально, двумерный массив — это обычная таблица, со строками и столбцами. Фактически двумерный массив — это одномерный массив одномерных массивов. Структура двумерного массива, с именем a , размером m на n показана ниже (см. Рисунок 4).
Рисунок 4 — Массивы в С++
где, m — количество строк двумерного массива;
n — количество столбцов двумерного массива;
m * n — количество элементов массива.
// синтаксис объявления двумерного массива /*тип данных*/ /*имя массива*/;
В объявлении двумерного массива, также как и в объявлении одномерного массива, первым делом, нужно указать:
- тип данных;
- имя массива.
После чего, в первых квадратных скобочках указывается количество строк двумерного массива, во вторых квадратных скобочках — количество столбцов двумерного массива. Двумерный массив визуально отличается от одномерного второй парой квадратных скобочек. Рассмотрим пример объявления двумерного массива. Допустим нам необходимо объявить двумерный массив, с количеством элементов, равным 15. В таком случае двумерный массив может иметь три строки и пять столбцов или пять строк и три столбца.
// пример объявление двумерного массива: int a;
- a — имя целочисленного массива
- число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;
- число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.
// инициализация двумерного массива: int a = { {4, 7, 8}, {9, 66, -1}, {5, -5, 0}, {3, -3, 30}, {1, 1, 1} };
В данном массиве 5 строк, 3 столбца. после знака присвоить ставятся общие фигурные скобочки, внутри которых ставится столько пар фигурных скобочек, сколько должно быть строк в двумерном массиве, причём эти скобочки разделяются запятыми. В каждой паре фигурных скобочек записывать через запятую элементы двумерного массива. Во всех фигурных скобочках количество элементов должно совпадать. Так как в массиве пять строк, то и внутренних пар скобочек тоже пять. Во внутренних скобочках записаны по три элемента, так как количество столбцов — три. Графически наш массив будет выглядеть, как двумерная таблица (см. Рисунок 5).
Рисунок 5 — Массивы в С++
В каждой ячейке двумерного массива a показано значение, в нижнем правом углу показан адрес данной ячейки. Адресом ячейки двумерного массива является имя массива, номер строки и номер столбца.
Разработаем несложную программу, на обработку двумерного массива, которая называется «Лабиринт». Лабиринт должен быть построен на основе двумерного массива. Размер лабиринта выберем на свое усмотрение.
// array2.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// array2.cpp: определяет точку входа для консольного приложения.
#include
Правильный и ложный пути можно было бы обозначать одной и той же цифрой, например, нулём, но для наглядности правильный путь обозначен цифрой 2. Инициализация массива выполнялась вручную, только для того, что бы упростить программу. Так как в программе выполняется обработка двумерного массива, нужны два цикла, для переключения между элементами двумерного массива. Первый цикл for выполняет переключение между строками двумерного массива. Так как строк в двумерном массиве 33, то и переменная-счетчик i инкрементируется от 0 до 33, строка 46 . Внутри первого цикла стоит цикл for , который переключается между элементами строки двумерного массива. В теле второго цикла for внутри выполняетcя унарная операция преобразования типа данных — static_cast<>() , которая печатает символ , под номером 176. операция преобразования типов данных дублируется для увеличения ширины лабиринта. Результат работы программы (см. Рисунок 6).
Рисунок 6 — Массивы в С++
До сих пор мы работали с простыми типами данных – логический (boolean), целый (integer , word , byte , longint), вещественный (real), символьный (char). Любой алгоритм можно запрограммировать с помощью этих четырех базовых типов. Но для обработки информации о многообразном реальном мире требуются данные, имеющие более сложное строение. Такие сложные конструкции, основанные на простейших скалярных типах, называются структурами. Структура – некоторый составной тип данных, составленный из базовых скалярных. Если структура не изменяет своего строения на протяжении всего выполнения программы, в которой она описана, то такую структуру называют статической.
Массив – однородная совокупность элементов
Самой распространенной структурой, реализованной практически во всех языках программирования, является массив.
Массивы состоят из ограниченного числа компонент, причем все компоненты массива имеют один и тот же тип, называемый базовым. Структура массива всегда однородна. Массив может состоять из элементов типа integer , real или char , либо других однотипных элементов. Из этого, правда, не следует делать вывод, что компоненты массива могут иметь только скалярный тип.
Другая особенность массива состоит в том, что к любой его компоненте можно обращаться произвольным образом. Что это значит? Программа может сразу получить нужный ей элемент по его порядковому номеру (индексу).
Индекс массива
Номер элемента массива называется индексом . Индекс – это значение порядкового типа, определенного, как тип индекса данного массива. Очень часто это целочисленный тип (integer , word или byte), но может быть и логический и символьный.
Описание массива в Паскале. В языке Паскаль тип массива задается с использованием специального слова array (англ. – массив), и его объявление в программе выглядит следующим образом:
Type < имя _ типа >= array [ I ] of T;
где I – тип индекса массива, T – тип его элементов.
Можно описывать сразу переменные типа массив, т.е. в разделе описания переменных:
Var a,b: array [ I ] of T;
Обычно тип индекса характеризуется некоторым диапазоном значений любого порядкового типа: I 1 .. I n . Например, индексы могут изменяться в диапазоне 1..20 или " a ".." n ".
При этом длину массива Паскаля характеризует выражение:
ord (I n)- ord (I 1)+1.
Вот, например, объявление двух типов: vector в виде массива Паскаля из 10 целых чисел и stroka в виде массива из 256 символов:
Type
Vector=array of integer;
Stroka=array of char;
С помощью индекса массива можно обращаться к отдельным элементам любого массива, как к обычной переменной: можно получать значение этого элемента, отдельно присваивать ему значение, использовать его в выражениях.
Опишем переменные типа vector и stroka:
Вычисление индекса массива Паскаля
Индекс массива в Паскале не обязательно задавать в явном виде. В качестве индекса массива можно использовать переменную или выражение, соответствующее индексному типу. Иначе говоря, индексы можно вычислять.
Этот механизм – весьма мощное средство программирования. Но он порождает распространенную ошибку: результат вычислений может оказаться за пределами интервала допустимых значений индекса, то есть будет произведена попытка обратиться к элементу, которого не существует. Эта типичная ошибка называется «выход за пределы массива».
Пример программы с ошибкой массива ПаскаляProgram primer _ error ;
Type
vector=array of word;
var
n: integer;
a: vector;
begin
n:=45;
a:=25;
end .
Хотя данная программа полностью соответствует синтаксису языка, и транслятор «пропустит» ее, на стадии выполнения произойдет ошибка выхода за пределы массива Паскаля. При n =45 выражение n *2=90, компьютер сделает попытку обратиться к элементу массива a , но такого элемента нет, поскольку описан массив размерностью 80.
Будем считать, что хорошая программа должна выдавать предупреждающее сообщение в случае попытки обращения к несуществующим элементам массива. Не лишним будет проверять возможный выход как за правую, так и за левую границы массива, ведь не исключено, что в результате вычисления значения выражения получится число, находящееся левее границы массива Паскаля.
Из всего этого следует сделать вывод: программисту надо быть очень аккуратным при работе с индексами массива.
Основные действия с массивами Паскаля
Как известно, определение типа данных означает ограничение области допустимых значений, внутреннее представление в ЭВМ, а также набор допустимых операций над данными этого типа. Мы определили тип данных как массив Паскаля. Какие же операции определены над этим типом данных? Единственное действие, которое можно выполнять над массивами целиком, причем только при условии, что массивы однотипны, – это присваивание. Если в программе описаны две переменные одного типа, например,
Var
a , b: array of real ;
то можно переменной a присвоить значение переменной b (a:= b). При этом каждому элементу массива a будет присвоено соответствующее значение из массива b . Все остальные действия над массивами Паскаля производятся поэлементно (это важно!) .
Ввод массива Паскаля
Для того чтобы ввести значения элементов массива, необходимо последовательно изменять значение индекса, начиная с первого до последнего, и вводить соответствующий элемент. Для реализации этих действий удобно использовать цикл с заданным числом повторений, т.е. простой арифметический цикл, где параметром цикла будет выступать переменная – индекс массива Паскаля. Значения элементов могут быть введены с клавиатуры или определены с помощью оператора присваивания.
Пример фрагмента программы ввода массива ПаскаляVar
A: array of integer ;
Begin
For i:=1 to 10 do
Readln (a[i]); { ввод i- го элемента производится с клавиатуры }
Рассмотрим теперь случай, когда массив Паскаля заполняется автоматически случайными числами, для этого будем использовать функцию random (N).
Пример фрагмента программы заполнения массива Паскаля случайными числамиVar
I: byte ; {переменная I вводится как индекс массива}
Begin
For i:=1 to 10 do
A [ i ]:= random (10); { i -му элементу массива присваивается «случайное» целое число в диапазоне от 0 до 10}
Вывод массива Паскаля
Вывод массива в Паскале осуществляется также поэлементно, в цикле, где параметром выступает индекс массива, принимая последовательно все значения от первого до последнего.
Пример фрагмента программы вывода массива ПаскаляVar
A: array of integer;
I: byte ; {переменная I вводится как индекс массива}
Begin
For i:=1 to 10 do
Write (a [ i ]," "); {вывод массива осуществляется в строку, после каждого элемента печатается пробел}
Вывод можно осуществить и в столбик с указанием соответствующего индекса. Но в таком случае нужно учитывать, что при большой размерности массива все элементы могут не поместиться на экране и будет происходить скроллинг, т.е. при заполнении всех строк экрана будет печататься очередной элемент, а верхний смещаться за пределы экрана.
Пример программы вывода массива Паскаля в столбикVar
A: array of integer;
I: byte ; {переменная I вводится как индекс массива}
Begin
For i:=1 to 10 do
Writeln ("a[", i,"]=", a[i]); { вывод элементов массива в столбик }
На экране мы увидим, к примеру, следующие значения:
a =2
a =4
a =1 и т.д.
Пример решения задачи с использованием массивов Паскаля
Задача: даны два n -мерных вектора. Найти сумму этих векторов.
Решение задачи:
- Входными данными в этой задаче будут являться два одномерных массива. Размер этих массивов может быть произвольным, но определенным. Т.е. мы можем описать заведомо большой массив, а в программе определить, сколько элементов реально будет использоваться. Элементы этих массивов могут быть целочисленными. Тогда описание будет выглядеть следующим образом:
var a , b: array of integer ;
- Выходными данными будут элементы результирующего массива, назовем его c . Тип результирующего массива также должен быть целочисленным.
- Кроме трех массивов нам потребуется переменная – параметр цикла и индекс массива, назовем ее i , а также переменная n для определения количества элементов в каждом массиве.
Ход решения задачи:
- определим количество элементов (размерность) массивов, введем значение n ;
- введем массив a ;
- введем массив b ;
- в цикле, перебирая значения индекса i от 1 до n , вычислим последовательно значения элементов массива c по формуле:
c [ i ]= a [ i ]+ b [ i ];
- выведем на экран полученный массив.
Текст программы:
Пример программы суммирования векторовProgram summa;
Var
a, b, c: array of integer;
I, n: byte;
Begin
Write ("введите размерность массивов:");
Readln(n);
For i:=1 to n do
Readln (a[i]); { ввод массива a}
For i:=1 to n do
Readln (b[i]); { ввод массива b}
For i:=1 to n do
C[i]:=a[i]+b[i]; { вычисление суммы массивов }
For i:=1 to n do
write (c[i]," "); { вывод массива с }
end.
На занятии объясняется, как работать с одномерными массивами в Паскале, как использовать генератор случайных чисел - функцию random в Паскале. Рассматривается пример того, как вывести числа Фибоначчи
Материалы сайта сайт направлены на практическое освоение языка программирования Pascal. Краткие теоретические сведения не претендуют на полное освещение материала по теме; необходимую информацию можно найти в сети Интернет в большом количестве. В наши же задачи входит предоставление возможности получения практических навыков программирования на Паскале. Решенные наглядные примеры и задания изложены по мере увеличения их сложности, что позволит с легкостью изучить материал с нуля.
Объявление массива
Массивы в Паскале используются двух типов: одномерные и двумерные.
Определение одномерного массива в Паскале
звучит так: одномерный массив - это определенное количество элементов, относящихся к одному и тому же типу данных, которые имеют одно имя, и каждый элемент имеет свой индекс — порядковый номер.
Описание массива в Паскале (объявление) и обращение к его элементам происходит следующим образом:
Объявление массива
var dlina: array [ 1 .. 3 ] of integer ; begin dlina[ 1 ] : = 500 ; dlina[ 2 ] : = 400 ; dlina[ 3 ] : = 150 ; ... var dlina: array of integer; begin dlina:=500; dlina:=400; dlina:=150; ...
Объявить размер можно через константу:
Инициализация массива
Кроме того, массив может быть сам константным , т.е. все его элементы в программе заранее определены. Описание такого массива выглядит следующим образом :
| const a: array [ 1 .. 4 ] of integer = (1 , 3 , 2 , 5 ) ; |
const a:array of integer = (1, 3, 2, 5);
Заполнение последовательными числами:
Результат: A = 8, A = 9, A = 10, ..., A[N] = A + 1
Ввод с клавиатуры:
Пример: Рассмотрим, как происходит ввод массива в Паскале:
writeln ("введите кол-во элементов: "); readln(n); {если кол-во заранее не известно, - запрашиваем его} for i:= 1 to n do begin write("a[", i, "]="); read(a[i]); ... end; ...
✍ Пример результата:
Введите кол-во элементов: 3 a=5 a=7 a=4
Вывод элементов массива
Пример: Рассмотрим, как вывести массив в Паскале:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | var a: array [ 1 .. 5 ] of integer ; {массив из пяти элементов} i: integer ; begin a[ 1 ] : = 2 ; a[ 2 ] : = 4 ; a[ 3 ] : = 8 ; a[ 4 ] : = 6 ; a[ 5 ] : = 3 ; writeln ("Массив A:" ) ; for i : = 1 to 5 do write (a[ i] : 2 ) ; {вывод элементов массива} end . |
var a: array of integer; {массив из пяти элементов} i: integer; begin a:=2; a:=4; a:=8; a:=6; a:=3; writeln("Массив A:"); for i:= 1 to 5 do write(a[i]:2); {вывод элементов массива} end.
✍ Пример результата:
Массив A: 2 4 8 6 3
Для работы с массивами чаще всего используется в Паскале с параметром, так как обычно известно, сколько элементов в массиве, и можно использовать счетчик цикла в качестве индексов элементов.
Задача Array 0. Необходимо задать вещественный массив размерностью 6 (т.е. из шести элементов); заполнить массив вводимыми значениями и вывести элементы на экран. Использовать два цикла: первый — для ввода элементов, второй — для вывода.
В данном примере работы с одномерным массивом есть явное неудобство: присваивание значений элементам.
Обработка массивов в Паскале, так же как и заполнение массива, происходит обычно с использованием цикла for .
Функция Random в Pascal
Для того чтобы постоянно не запрашивать значения элементов массива используется генератор случайных чисел в Паскаль, который реализуется функцией Random . На самом деле генерируются псевдослучайные числа, но суть не в этом.
Для генерации чисел от 0 до n (не включая само значение n , целые числа в интервале of integer; i:integer; begin randomize; for i:=1 to 10 do begin f[i]:=random(10); { интервал } write(f[i]," "); end; end.
✍ Пример результата:
9 8 9 2 0 3 6 9 5 0
Для вещественных чисел в интервале и вывести элементы на экран: определить три позиции для вывода каждого элемента.
Числа Фибоначчи в Паскале
Наиболее распространенным примером работы с массивом является вывод ряда чисел Фибоначчи в Паскаль. Рассмотрим его.
Пример: Ряд чисел Фибоначчи: 1 1 2 3 5 8 13…
f[ 0 ] : = 1 ; f[ 1 ] : = 1 ; f[ 2 ] : = 2 ; … f:=1; f:=1; f:=2; …
f[ 2 ] : = f[ 0 ] + f[ 1 ] ; f[ 3 ] : = f[ 1 ] + f[ 2 ] ;
f[ i] : = f[ i- 2 ] + f[ i- 1 ] ; f[i]:=f+f;
Получили формулу элементов ряда.
Пример: Вычислить и распечатать первые 20 чисел Фибоначчи.
| 1 2 3 4 5 6 7 8 9 10 11 | var i: integer ; f: array [ 0 .. 19 ] of integer ; begin f[ 0 ] : = 1 ; f[ 1 ] : = 1 ; for i: = 2 to 19 do begin f[ i] : = f[ i- 1 ] + f[ i- 2 ] ; writeln (f[ i] ) end ; end . |
var i:integer; f:arrayof integer; begin f:=1; f:=1; for i:=2 to 19 do begin f[i]:=f+f; writeln(f[i]) end; end.
На данном примере, становится понятен принцип работы с числовыми рядами. Обычно, для вывода числового ряда находится формула определения каждого элемента данного ряда. Так, в случае с числами Фибоначчи, эта формула-правило выглядит как f[i]:=f+f . Поэтому ее необходимо использовать в цикле for при формировании элементов массива.
Задача Array 2. Дан ряд из 10 произвольных чисел: a, a, ... , a (использовать функцию random()). Подсчитать и напечатать суммы троек стоящих рядом чисел: a+a+a , a+a+a , a+a+a , …… , a+a+a
Псевдокод:
Поиск максимального элемента по его индексу:
Задание Array_min: Найдите минимальный элемент массива. Выведите элемент и его индекс.
Задача Array 4. Дан массив из 10 целочисленных элементов. Найти количество отрицательных и вывести количество на экран.
Задача Array 5. Найти минимальное и максимальное из n введенных чисел (массива). Определить расстояние между этими элементами. 3 2 6 1 3 4 7 2 >>> min=1, max=7, distance=3
Задача Array 6. Дан целочисленный массив размера N . Вывести все содержащиеся в данном массиве четные числа в порядке убывания их индексов, а также их количество K . N=4 mas: 8 9 2 5 >>> 2 8 количество= 2
Задача Array 7. Ввести с клавиатуры массив из 5 элементов, найти в нем два максимальных элемента и их номера.
Пример:
Исходный массив: 4 -5 10 -10 5 максимальные A=10, A=5
Поиск в массиве
Рассмотрим сложный пример работы с одномерными массивами:
Пример:
Дан массив из 10 чисел. Определить, есть ли в массиве число, введенное пользователем. Если есть – выводить «найдено»
, если нет – «не найдено»
.
Сложность задания заключается в том, что выводить слова «найдено»
или «не найдено»
необходимо один раз.
Для решения поставленной задачи понадобится оператор break — выход из цикла.
Решение Вариант 1. Цикл for:
Показать решение
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | var f: array [ 1 .. 10 ] of integer ; flag: boolean ; i, c: integer ; begin randomize; for i: = 1 to 10 do begin f[ i] : = random(10 ) ; write (f[ i] , " " ) ; end ; flag: = false ; writeln ("введите образец" ) ; readln (c) ; for i: = 1 to 10 do if f[ i] = c then begin writeln ("найден" ) ; flag: = true ; break ; end ; if flag= false then writeln ("не найден" ) ; end . |
var f: array of integer; flag:boolean; i,c:integer; begin randomize; for i:=1 to 10 do begin f[i]:=random(10); write(f[i]," "); end; flag:=false; writeln("введите образец"); readln(c); for i:=1 to 10 do if f[i]=c then begin writeln("найден"); flag:=true; break; end; if flag=false then writeln("не найден"); end.
Рассмотрим эффективное решение:
Задача: найти в массиве элемент, равный X , или установить, что его нет.
Алгоритм:
- начать с 1-го элемента (i:=1);
- если очередной элемент (A[i]) равен X , то закончить поиск иначе перейти к следующему элементу.
решение на Паскале Вариант 2. Цикл While:
Предлагаем посмотреть подробный видео разбор поиска элемента в массиве (эффективный алгоритм):
Задача Array 8. Заполнить массив из 10 элементов случайными числами в интервале и вывести номера всех элементов, равных X .
Пример:
Исходный массив: 4 0 1 2 0 1 3 4 1 0 Что ищем? 0 A, A, A
Циклический сдвиг
Пример:
сдвинуть элементы массива влево на 1 позицию, первый элемент становится на место последнего.
Решение:
Алгоритм:
A:=A; A:=A;… A:=A[N];
Программа:
Задача Array 9.
Заполнить массив из 10 элементов случайными числами в интервале [-10..10] и выполнить циклический сдвиг влево без первого элемента
.
Пример:
Исходный массив:
4 -5 3 10 -4 -6 8 -10 1 0
Результат:
4 3 10 -4 -6 8 -10 1 0 -5
Перестановка элементов в массиве
Рассмотрим, как происходит перестановка или реверс массива.
Пример:
переставить элементы массива в обратном порядке
Решение:
Алгоритм:
Псевдокод:
Программа:
Задача Array 10.
Заполнить массив из 10 элементов случайными числами в интервале [-10..10] и сделать реверс всех элементов, кроме последнего.
Пример:
Исходный массив:
-5 3 10 -4 -6 8 -10 1 0 4
Результат:
0 1 -10 8 -6 -4 10 3 -5 4
Выбор элементов и сохранение в другой массив
Пример:
найти в массиве элементы, удовлетворяющие некоторому условию (например, отрицательные), и скопировать их в другой массив
Решение:
Решение: подсчитывать количество найденных элементов с помощью счетчика count, очередной элемент устанавливать на место B. Переменой count необходимо присвоить 1 .
Вывод массива B:
writeln("Выбранные элементы"); for i:=1 to count-1 do write(B[i], " ")
Задача Array 11.
Заполнить массив случайными числами в интервале и записать в другой массив все числа, которые оканчиваются на 0.
Пример:
Исходный массив:
40 57 30 71 84
Заканчиваются на 0:
40 30
Сортировка элементов массива
Сортировка методом «Пузырька»
- В таком типе сортировок массив представляется в виде воды, маленькие элементы — пузырьки в воде, которые всплывают наверх (самые легкие).
- При первой итерации цикла элементы массива попарно сравниваются между собой:предпоследний с последним, пред предпоследний с предпоследним и т.д. Если предшествующий элемент оказывается больше последующего, то производится их обмен.
- При второй итерации цикла нет надобности сравнивать последний элемент с предпоследним. Последний элемент уже стоит на своем месте, он самый большой. Значит, число сравнений будет на одно меньше. То же самое касается каждой последующей итерации.
Выполнение на Паскале:
| 1 2 3 4 5 6 7 8 | for i: = 1 to N- 1 do begin for j: = N- 1 downto i do if A[ j] > A[ j+ 1 ] then begin с : = A[ j] ; A[ j] : = A[ j+ 1 ] ; A[ j+ 1 ] : = с; end ; end ; |
for i:=1 to N-1 do begin for j:=N-1 downto i do if A[j] > A then begin с:= A[j]; A[j] := A; A := с; end; end;
Задание Array 12. Заполнить массив из 10 элементов случайными числами в интервале и отсортировать первую половину массива по возрастанию, а вторую – по убыванию (методом ‘Пузырька’). Пример: Исходный массив: 14 25 13 30 76 58 32 11 41 97 Результат: 13 14 25 30 76 97 58 41 32 11
Сортировка методом выбора
- в массиве ищется минимальный элемент и ставится на первое место (меняется местами с A);
- среди оставшихся элементов также производится поиск минимального, который ставится на второе место (меняется местами с A) и т.д.
for i:= 1 to N-1 do begin min:= i ; for j:= i+1 to N do if A[j] < A then min:=j; if min <> i then begin c:=A[i]; A[i]:=A; A:=c; end; end;
Задание Array 13: Заполнить массив из 10 элементов случайными числами в интервале и отсортировать его по возрастанию суммы цифр Пример: Исходный массив: 14 25 13 12 76 58 21 87 10 98 Результат: 10 21 12 13 14 25 76 58 87 98
Быстрая сортировка или quick sort
Алгоритм:
Выполнение на Паскале:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | procedure QSort ( first, last: integer ) ; var L, R, c, X: integer ; begin if first < last then begin X: = A[ (first + last) div 2 ] ; L: = first; R: = last; while L <= R do begin while A[ L] < X do L: = L + 1 ; while A[ R] > X do R: = R - 1 ; if L <= R then begin c: = A[ L] ; A[ L] : = A[ R] ; A[ R] : = c; L: = L + 1 ; R: = R - 1 ; end ; end ; QSort(first, R) ; QSort(L, last) ; end ; end . |
procedure QSort (first, last: integer); var L, R, c, X: integer; begin if first < last then begin X:= A[(first + last) div 2]; L:= first; R:= last; while L <= R do begin while A[L] < X do L:= L + 1; while A[R] > X do R:= R - 1; if L <= R then begin c:= A[L]; A[L]:= A[R]; A[R]:= c; L:= L + 1; R:= R - 1; end; end; QSort(first, R); QSort(L, last); end; end.
Задание Array 14:
Заполнить массив из 10 элементов случайными числами в интервале [-50..50] и отсортировать его с помощью алгоритма быстрой сортировки.
Массив в программировании является набором элементов одного типа (однотипных).
Различают несколько видов массивов – одномерный (векторный) и многомерный .
Элементы в массиве характеризуются своими именами и порядковыми номерами - индексами.
Индекс – это порядковый номер элемента в массиве.
В Паскале каждому элементу присваивается один или несколько индексов, которые описывают положение элемента в массиве.
Одномерный массив
Синтаксис массива в Pascal таков:Var a: array Of integer ;
Где:
1 – нижний индекс
10 – верхний индекс
A – имя переменной массива
– диапазон значений
Integer – тип данных
A[ i ] – обращение к элементу массива в Pascal
Тип элементов массива может быть любым допустимым типом в Pascal, кроме файлов (даже массивом).
Пример массива: A = {1,-5,230,55,-88,0,100}
Когда описывается массив, его верхний индекс должен быть строго определён.
При описании массива идёт распределение памяти, и компилятор должен знать какое количество памяти нужно выделить под описанный массив.
Ограничения по количеству индексов в массиве Pascal не ограничивается. Однако сам массив не должен быть больше чем 65537 байт.
Массив также можно объявлять в разделе описания типов:
Type mass = array Of real ;
Var a,b,c: mass ;
Доступ к элементам массива осуществляется в цикле.
Наиболее рациональным способом обработки элементов массива в Паскаль является оператор цикла с параметром.
Как думаете почему? Да потому, что нам известно конечное число элементов в массиве.
Алгоритмы заполнения массива в Pascal
- Ввод элементов массива с помощью компьютера осуществляется с помощью такой конструкции:
For i:= 1 To 10 Do read(A[i]);
- Задание массива случайным образом.
Массив можно задать случайным образом с помощью датчика случайных величин.
Для запуска датчика случайных величин в Паскаль нужно прописать специальную конструкцию - Randomize ;
Новое значение генерируется с помощью функции Random(n) ,где n – целое число. В таком случае генерируется любое число с диапазоном от 0 до n.
K:= Random (100);
Если функция Random используется без параметра, то она генерирует вещественное число (тип real) в диапазоне 0 < X < 1X:= Random ;
Заполнение массива случайным образом
Данная конструкция в Pascal реализует заполнение массива случайно.Randomize ; For i:= 1 To 10 Do Begin A[i] := random*100-70 ; write(A[i]:6:2) ; End ;
Разделы: Информатика
Цели:
- Познакомить учащихся с возможностью заполнения и обработки массива.
- Создать графический интерфейс проекта по заполнению массива и подсчета суммы элементов в заданном массиве.
- Развивать познавательный интерес к предмету
- Воспитывать ответственное отношение к обучению
ХОД УРОКА
1. Актуализация урока
Организационный момент
Фронтальный опрос по предыдущей теме “Понятие массива. Одномерный массив”
2. Формирование умений и навыков
Объяснение нового материала
Объявление массива
Объявление массива производится аналогично объявлению переменных, необходимо только указать диапазон изменения индекса. Например, объявление одномерного целочисленного массива, содержащего 10 элементов, производится следующим образом:
A: array of integer;
Основные задачи при работе с массивами
1. Формирование (заполнение) массива
1.1. по формулам For i:=1 to 10 do a[i]:= i*i;
1.2. сгенерировать случайным образом For i:=1 to 10 do a[i]:= random(20):
Встроенная функция RANDOM(MAX), возвращает случайное целое число, равномерно распределенное в диапазоне от 0 до МАХ – 1(МАХ – параметр обращения)
1.3. ввести с клавиатуры For i:=1 to 10 do read(a[i]);
2. Сортировка массива (по возрастанию, по убыванию);
3. Поиск элементов в массиве;
4. Выбор элементов из массива по условию;
Заполнение массива случайным образом.
Для начала работы с массивом его необходимо заполнить, т.е. присвоить элементам массива определенные значения. Для генерации последовательности случайных чисел используем функцию Random(100). При запуске программы данная функция выведет псевдослучайную последовательность целых чисел в интервале от 0 до 100.
Для генерации различающихся между собой последовательностей случайных чисел рекомендуется использовать оператор Randomize
Действия с одномерными массивами
1. Вычисление суммы элементов
For I:= 1 To 10 Do s:=s+ a[i]; (обычное накопление суммы в s)
2. Вычисление произведения
For I:= 1 To 10 Do р:=р* a[i]; (обычное накопление произведения в р)
3. Поиск элемента с заданным значением
3. Прим енение умений и навыков на практике
Проект “Сумма элементов в массиве”. Разработаем проект “Сумма элементов в массиве”, который будет производить заполнение массива случайными числами и вычислять сумму этих чисел
Для начала создадим процедуру заполнения массива
1.Запустить систему программирования Delphi.
2. Работа над проектом начинается с создания графического интерфейса, для этого в окне Конструктор форм на форму помещаются управляющие элементы. Для создания графического интерфейса проекта разместим на форме два текстовых поля для вывода числовых данных (одно – заполнение массива, другое – вывод суммы) и две кнопки для реализации событийных процедур: заполнение массива и сумма
3. С помощью Панели инструментов поместить на форму Forml текстовое поле Editl и командную кнопку Buttonl
Следующим шагом является создание программного кода событийных процедур. Двойной щелчок мышью по кнопке, для которой надо создать программный код, вызывает окно Программный код с пустой заготовкой событийной процедуры.
4. Осуществить двойной щелчок по кнопке Buttonl, появится заготовка событийной процедуры TForml.ButtonlClick: Произвести объявление массива A и описание переменных I, S в разделе описания переменных var
A:array of integer;
procedure TForm1.Button1Click(Sender: TObject);
For I:= 1 To 10 Do
A[I] := Random(10);
Edit1.Text:= Edit1.Text +" " + IntToStr(a[i]);
5. Сохранение проекта (Save Project As)
6. Компиляция проекта (Project - Compile)
Теперь создадим процедуру для вычисления суммы элементов в заполненном массиве
С помощью Панели инструментов п оместим на форму Forml кнопку Button2 и текстовое поле Edit2. Двойной щелчок мышью по кнопке Button2, для которой надо создать программный код, вызывает окно Программный код с пустой заготовкой событийной процедуры.
procedure TForm1.Button2Click(Sender: TObject);
For I:= 1 To 10 Do
Edit2.Text:= Edit2.Text +" " + IntToStr(s)
Сохранение проекта всего проекта (Save Project).
Произведем компиляцию проекта (нажатием клавиши F9).
Щелкнуть по кнопкам Заполнить массив и Сумма.
В текстовое поле будут выведены результаты сумм при различных вариантах заполнения
4. Подведение итогов
5. Домашнее задание: Создать проект “Произведение элементов массива”, предусматривающий заполнение массива случайными числами и возможность вывода в текстовое поле произведение всех элементов в массиве.
