Что такое индекс в одномерном массиве
Перейти к содержимому

Что такое индекс в одномерном массиве

  • автор:

Индексы одномерного массива.

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

Пример 30. Дана последовательность вещественных чисел X1, Х2, X3. Х24. Требуется вычислить U = X1 • Х2 • Х3 • X4 + X4 • Х6 • Х7 • Х8 + . + Х21 • Х22 • X23 • Х24

Для программирования необходимо линейную формулу U преобразовать к следующему виду:

Нетрудно заметить, что задача сведена к двойному арифметическому циклу. Для накопления суммы по I используется переменная U, исходное состояние которой равно 0. Для накопления произведения используется рабочая переменная Р, которая рассчитывается шесть раз для значений индекса I=1,2,…,6. Вы можете скачать realtek hd, новую версию драйверов, которая подойдет для Windows 8.1. Для накопления произведения начальное значение J принимается равным 1.

PROGRAM PR30;
VAR
X: ARRAY [1.. 24] OF REAL;
I, J: INTEGER;
U, P: REAL;
BEGIN
WRITELN(‘Введите массив X, из 24 вещественных чисел’);
FOR I := 1 ТО 24 DO READ(X[I]);
U := 0;
FOR I := 1 TO 6
DO BEGIN
P := 1;
FOR J := 1 TO 4
DO P:=P*X[4*(I-1)+J];
U := U + P
END;
WRITELN(‘U =’, U:10:2)
END.

Что такое индекс в одномерном массиве

Введение

Линейные алгоритмы

Алгоритмы с ветвлением

Алгоритмы с повторением

Одномерный массив (вектор)

Двумерный массив (матрица)

Пользовательские процедуры и функции

Строки

Множества

Записи

Файлы

Одномерные массивы

I. Объявление массивов

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

Количество элементов и их номера задаются с помощью типа индекса ( индексом называется значение, по которому элементы массива отличают один от другого, например, индексами могут быть 1, 2, 10, ‘a’, false и т.д.). Тип индекса — это один из следующих: ограниченный целый тип ( byte может быть без ограничения), символьный тип (ограниченный или целиком), логический тип и любой перечислимый тип. Вещественный тип типом индекса служить не может. Чаще всего используется целый ограниченный тип, тогда об индексе элемента говорят как о его номере. Пример описания массива:

var A: array [1..10] of integer;

Здесь тип элементов — integer, тип индекса — ограниченный целый тип 1..10. В этом массиве индексами элементов будут целые числа 1, 2, 3, 4,5, 6, 7, 8, 9, 10.

А в массиве var A: array [5..12] of integer;

индексами являются 5, 6, 7, 8, 9, 10, 11, 12.

Назначение индекса — указать, какой из элементов массива имеется в виду, ведь имя-то у всех одно и тоже. Поэтому если написано A[7], то очевидно, что это элемент массива A с индексом 7. Причем в первом массиве это будет седьмой элемент, а во втором — третий, так что порядковый номер элемента в массиве и его индекс — это далеко не одно и тоже. Как определить, сколько в массиве элементов? Их там столько же, сколько различных индексов в типе индекса (в первом массиве — 10, во втором — 8).

Синтаксис описания одномерного (т.е. с одним индексом) массива:

Если в качестве индексов используются номера (целые числа), синтаксис можно несколько конкретизировать:
array [.. ] of
и задают первый и последний номер элемента соответственно.
Примеры:
var A, B: array [‘a’..’z’] of integer;
var C: array [ boolean] of real;
var D: array [(red, green, blue)] of char;
var E: array [100..150] of boolean;

Внимание! В описании типа индексов нельзя использовать переменные. Во многих задачах необходимо «ввести массив из n элементов». Однако нельзя объявить массив как var A: array [1.. n] of integer;
если n — переменная. Границы изменения индекса должны задавать только константы . Рекомендуется в таких случаях вместо n в объявлении массива указывать максимально возможное (в пределах разумного) число элементов, например:
var A: array [1..50] of integer;
а потом указать, что n не должно превышать 50-ти.
Рекомендуется также давать имена типам массивов, если массивов в задаче больше одного. Например, так:
type massiv = array [1..50] of integer;
var A, B: massiv;
Иначе может возникнуть несовместимость типов.

II. Имена элементов массива

Следующий вопрос: как указать имя конкретного элемента массива? Имен-то у них нет?
Необходимо указать имя массива, откуда берется элемент и индекс этого элемента в данном массиве:
[]
Например, для массива
var A: array [1..50] of integer;
5-тый элемент имеет имя A[5], а для массива С из предыдущего пункта второй элемент называется С[ true]. В квадратных скобках может указываться не только константа, но и выражение (выражение должно иметь результат того же типа, что и тип индекса). Для массива A это целое выражение, например A[i+k-1], а для массива C — логическое (т.к. типом индекса у него служит логический), например С[(y>0) and (x
<>2)]. В таком случае индексом будет результат вычисления этого выражения. Если i = 7, k = 3, x = 11, y =5.5, это будут соответственно элементы A[9] и C[true].

III. Ввод и вывод одномерных массивов

Массивы нужно вводить (и выводить) поэлементно. Почему? Да потому, что оператор readln способен прочитать только значения типов integer, real и char и их простых производных. А массив — это несколько переменных, и их нужно читать по одной.
Массивы вводят и выводят с помощью цикла (понятно, почему ввод массива — циклическое действие?). Для любых одномерных массивов эти циклы очень похожи. Их общий вид:

Здесь: должна иметь тип индекса или базовый для него (например, для индекса ограниченного целого типа может быть целой).
Замените названия в <> на названия и значения Вашей задачи — и получите нужные циклы ввода и вывода массива.
Например, для массива

var A: array [1..50] of integer;
var i: integer;
они выглядят так:

for i := 1 to 50 do
begin
write(‘Введите A[‘, i, ‘]=’);
readln(A[i]);
end;

IV. Примеры решения задач с использованием массивов.

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

«Линейная» схема решения:
1. Ввести массив.
2. Подсчитать количество нечетных положительных элементов.
3. Вывести результат.

Ввод-вывод уже разобран. Только: чтобы ввести n элементов, надо сначала ввести n, и в цикле ввода задать его в качестве верхней границы (если нижняя равна 1). Осталось только выяснить, как считать требуемые элементы. Это просто: для каждого элемента проверить, является ли он положительным и не делится ли на два, и если оба условия выполнены, добавить к количеству положительных нечетных чисел единицу. Не правда ли, очевидно циклические действия? Перед тем, как начать цикл проверки, количество положительных нечетных надо, конечно, обнулить. Получаем следующий алгоритм:

1. Ввести n. Если n меньше нуля или больше максимального значения то вывести сообщение «Неверные исходные данные», иначе
2. Ввести массив из n элементов
3. Обнулить количество положительных нечетных элементов
4. Для каждого элемента массива от 1 до n:
если элемент > 0 и не делится на 2 то увеличить количество положительных нечетных элементов на 1
5. Вывести количество положительных нечетных элементов
На основании которого напишем программу на Паскале (количество положительных нечетных элементов будем хранить в переменной count):

program prim1;
uses crt;
type massiv: array [1..50] of integer;
var a: massiv;
n, i, count: integer;
begin
clrscr;
textcolor(yellow);
writeln(‘Определение количества положительных нечетных элементов’);
write(‘Введите n=’);
readln(n);
if (n<0) or (n>50) then writeln(‘n должно быть больше 0 и меньше 50’)
else
begin
for i := 1 to n do
begin
write(‘Введите a[‘, i, ‘]=’);
readln(a[i]);
end;
count := 0;
for i := 1 to n do
begin
if (a[i] > 0) and (a[i] mod 2 = 0) then count := count + 1;
end;
writeln(‘В этом массиве таких элементов ‘, count);
end;
readln;
end.

Еще один пример.

Ввести массив из вещественных чисел длины n и преобразовать по правилу: от каждого положительного элемента взять sin, от каждого отрицательного — cos. Нули не трогать. Получившийся массив вывести.

1. Ввести n. Если n меньше нуля или больше максимального значения, вывести сообщение «Неверные исходные данные», иначе
2. Ввести массив из n элементов
3. Для каждого элемента массива от 1 до n:
4. если элемент > 0 то занести на его место sin от него
если элемент < 0 то занести на его место cos от него
5. Вывести массив

Одномерные массивы

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

Доступ к отдельной переменной осуществляется по индексу.

Индекс определяет положение элемента в массиве. Индекс элемента массива и его содержимое – это разные понятия.

Объявление одномерного массива, синтаксис: тип_ массива имя_массива [ число элементов массива ]

Правила объявления массива:

  1. Индекс первого элемента массива в С++ равен 0 (нулю).
  2. Объявление массива в С++ влечет за собой точное определение числа его элементов (количество элементов массива должно быть всегда целым числом).
  3. Доступ к отдельным элементам массива осуществляется по имени массива и индексу элемента массива: a[0] = 1; a[1] = 2 .
  4. В инструкции объявления массива удобно использовать константу, объявленную в директиве # define N 5

Правила использования элементов массива:

  1. Необходимо присваивать значение элементу массива до того, как он будет считываться
  2. При решении задач использовать допустимый индекс int mas[10]; // объявленный массив x = mas[11]; // ошибка, элементы с таким индексом не существуют
  3. В качестве индекса элемента массива можно использовать выражение целого типа – константу или переменную

x[2*i — 1]; mas[i + 1]; a[2*i]

Инициализация массивов

Инициализацию массивов можно проводить при их объявлении.

mas[0] = 2; mas[4] = 12; mas[8] = 1; mas[11] = 9;

Если в списке инициализации значений указано меньше, чем объявлено в размере массива, то имеет место частичная инициализация. В этом случае иногда после последнего значения в инициализирующем выражении для наглядности ставят запятую:

int mas[12] = ; или int mas[12] = ;

остальные элементы принимают значение равные нулю.

int mas[10] = – массив mas [10] инициализирован нулевыми элементами.

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

int mas[ ] = ;

Если в программе потребуется определить, сколько элементов в массиве, то можно воспользоваться формулой

int size = sizeof (mas) / sizeof (mas[0]); где

sizeof (mas) определяет возвращает общий размер, занимаемый массивом mas[ ] в памяти (в байтах);

sizeof (mas[0]) — размер одного элемента массива/

sizeof – оператор для определения числа байтов, необходимых для хранения объекта

Ввод элементов массива

Что такое индекс в одномерном массиве

Массив — это группа последовательных ячеек памяти, имеющих один и тот же тип. Чтобы обратиться к определенной ячейке, или элементу массива, мы используем имя массива и индекс (номер) элемента в массиве. При описании задается количество элементов в массиве в квадратных скобках, и дальнейший доступ к элементам массива осуществляется с помощью оператора []. Нумерация элементов массива начинается с 0, т.е. если в массиве 4 элемента, номера элементов будут от 0 до 3:

int data[4]; // описание массива из 4 элементов // инициализация элементов массива, обращение к элементам массива по индексу data[0]=1; data[1]=2; data[2]=3; data[3]=4;

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

// массив из трех элементов 0-го, 1-го, 2-го. Элементы нумеруются от 0 до размер-1 double v[3]=; // количество элементов указывать не обязательно char symbols[]='a', 'b', 'c', 'd', 'e'>;

3.1.2. Динамическое размещение одномерного массива

Массивы с небольшим количеством элементов легко размещаются в статической памяти программы. Но для массивов с большим количеством элементов намного эффективнее будет динамическое размещение (а для массивов с очень большим количеством элементов это необходимо, так как размер сегмента данных ограничен). В этом случае объявляется указатель на массив, а затем при помощи ключевого слова new выделяется память для требуемого количества элементов. Далее при работе с массивом доступ к элементам массива осуществляется одинаково, независимо от того как он размещен в памяти. Если массив размещается динамически, в конце программы обязательно нужно освободить память при помощи оператора delete.

double *data; // указатель на массив data=new double[1000]; // указатель на 0-й элемент массива // инициализация // после размещения в массиве "мусор" и сразу обязательно инициализировать все его элементы for(int i=0; i delete [] data; // обязательно освободить память data+1; // указатель на 1-й элемент data+100; // указатель на 100-й элемент, *(data+4); // эквивалентно data[4]

3.1.3. Передача массива в функцию (пример 3.1)

Передача массива в функцию может осуществляться только по указателю на нулевой элемент, с дополнительной информацией о количестве элементов в массиве:

///////////////////////////////////////////////////////////////////////////// // Прикладное программирование // Пример 3.1. Пример работы с динамическим одномерным массивом // // Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru // Университет ИТМО ///////////////////////////////////////////////////////////////////////////// // подключение библиотеки ввода-вывода #include // подключение стандартного пространства имен для использования библиотек using namespace std; // прототипы функций double sum(double data[], int n); ///////////////////////////////////////////////////////////////////////////// // пример передачи массива в функцию // функция вычисляет сумму всех элементов массива // data - массив (указатель на 0-й элемент массива) // n - количество элементов в массиве double sum(double data[], int n) < double sum=0.; for(int i=0; i return sum; > ///////////////////////////////////////////////////////////////////////////// void main() < // объявление указателя на массив double *data; int count=1000; // количество элементов в массиве // динамическое размещение массива, data - указатель на 0-й элемент массива data=new double[count]; // вывод 10 элементов массива до инициализации (в массиве "мусор") for(int i=0; i cout"-----------------"// инициализация массива for(int i=0; i // вывод 10 элементов массива после инициализации for(int i=0; i cout"-----------------"< cout< cout<<*(data+4)// эквивалентно data[4] cout< cout"-----------------"// пример передачи массива в функцию cout<delete [] data; // обязательно освободить память cout< > /////////////////////////////////////////////////////////////////////////////

3.1.4. Двумерный массив

Для создания двумерного массива необходимо указать в квадратных скобках два значения – количество строк и столбцов в массиве.

тип_массива имя_массива[кол-во строк][кол-во столбцов];

Рисунок иллюстрирует индексы элементов двумерного массива. Массив содержит три строки и два столбца.

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

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