Презентация на тему Массивы

данных, которая содержит множество значений, относящихся к одному и

тому же типу.

Каждому элементу массива отводится одна ячейка памяти.
Элементы одного массива занимают последовательно расположенные ячейки памяти.
Все элементы имеют одно имя - имя массива и отличаются индексами – порядковыми номерами в массиве.
Количество элементов в массиве называется его размером.

которым осуществляется по индексу (индексам).

Массивы в С++ – это

производные типы данных.

Можно объявлять переменные типов-массивов.

Объявление с инициализацией.
// Число элементов можно не указывать компилятор

посчитает сам
char hello[] = {'h', 'e', 'l', 'l', 'o'};
// Объявление с меньшим количеством
// значений в списке инициализации
int a[5] = {1, 2, 3};
// Оставшиеся два элемента проинициализируются нулями

т.е. компилятор должен уметь его вычислить во время компиляции
//

Целочисленное выражение
int arr[10 + 5*3];
// Операция sizeof() выполняется во время компиляции!
int arr[sizeof(int)*8 + 1];
// Выражение с константными переменными
const int Size = 10;
int arr[Size/2];
// Константы, определённые посредством #define
#define MAX_PATH 255
char filename[MAX_PATH + 1];

sizeof(int) * 12;

Адресация в массиве:

квадратных скобок
int a[10];
// Для компиляции индекс должен быть
// целочисленным

выражением
a[i+j/2] = 3; // i и j имеют целочисленный тип
a[0] = 90; // обращение к первому элементу
a[9] = -90; // обращение к последнему элементу
// Для правильной работы индекс должен быть
// от 0 до размера массива минус 1
a[55] = 30; // обращение к несуществующему элементу!
a[-5] = 30; // обращение к несуществующему элементу!

[5] = {34, 56, -21, 5002, 365};

Динамический
тип_элемента указатель на

имя_массива = оператор выделения памяти тип_элементов[переменная];
int *p_darr = new int[num];
Одномерный или Многомерный

размер которых фиксируется программистом во время компиляции.

Такой массив

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

размер которых может меняться во время исполнения программы.
int num

= 10;
int mass[num]; // не верно!
Псевдодинамический массив
const int MAX_SIZE=100;//именованная константа
int mass[MAX_SIZE];
int num = 10;
int *mass = new int[num]; // Верно! Выделяем память.
delete []mass; // Освобождаем память.

20 одномерных массивов размерности 10.
int MyArray2[20][10];
30 двумерных массивов

размерности 20*10.
int MyArray3[30][20][10];

Многомерные массивы в C++ рассматриваются как массивы, элементами которых являются массивы.

Например, массив с описанием int a[4][5] – это массив

из 4 указателей типа int*, которые содержат адреса одномерных массивов из 5 целых элементов.

следующие элементы трёхмерного массива:
MyArray[0][0][0] == 0
MyArray[0][0][1] == 1
MyArray[0][0][2] ==

2
MyArray[0][1][0] == 3
MyArray[0][1][1] == 4
MyArray[0][1][2] == 5
MyArray[0][2][0] == 6
MyArray[0][2][1] == 7
MyArray[0][2][2] == 8
MyArray[1][0][0] == 9
MyArray[1][0][1] == 10
MyArray[1][0][2] == 11

};
MyArray[0][0][0] == 0
MyArray[0][0][1] == 1
MyArray[1][0][0] ==

100
MyArray[1][1][0] == 200
MyArray[1][1][1] == 210
MyArray[1][2][0] == 300
MyArray[2][0][0] == 1000
MyArray[2][1][0] == 2000
MyArray[2][1][1] == 2100
MyArray[2][2][0] == 3000
MyArray[2][2][1] == 3100
MyArray[2][2][2] == 3200

обрабатываемых элементов;
характером изменения индексов.
По направлению перебора массивы обрабатывают:
слева

направо (от начала массива к его концу);
справа налево (от конца массива к началу);
от обоих концов к середине.
Индексы могут меняться:
линейно (с постоянным шагом);
нелинейно (с переменным шагом).

Перебор массива по одному элементу
Слева направо с шагом 1,

используя цикл с параметром:
for(int I=0;IСлева направо с шагом отличным от 1, используя цикл с параметром:
for (int I=0;IСправа налево с шагом 1, используя цикл с параметром:
for(int I=n-1;I>=0;I--){обработка a[I];}
Справа налево с шагом отличным от 1, используя цикл с параметром:
for (int I=n-1;I>=0;I-=step){обработка a[I];}

argc, char* argv[])
{
int a[100];
int n;
coutn;
for(int

I=0;I{a[I]=rand()%100-50; // случайные числа от -50 до 50
cout<}
system("pause");
return 0;
}

argc, char* argv[])
{
int a[100];
int n;
coutn;
for(int

I=0;Iint max=a[0];
for(int I=1;Imax)max=a[I];}
cout<<"\nMax="< system("pause");
return 0;
}

относятся задачи, в которых выполняется однотипная обработка всех или

указанных элементов массива.

К задачам 2 класса относятся задачи, в которых изменяется порядок следования элементов массива.

К задачам 3 класса относятся задачи, в которых выполняется обработка нескольких массивов или подмассивов одного массива. Массивы могут обрабатываться по одной схеме – синхронная обработка или по разным схемам – асинхронная обработка массивов.

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

арифметического массива
#include
#include
void main()
{
int a[100];
int n;
coutn;
for(int

I=0;Iint Sum=0;
for(I=0;ISum+=a[I];
Cout<<"Среднее арифметическое= " << Sum/n”;
}

r=a[i];
a[i]=a[j];
a[j]=r;}

Поменять местами
пары элементов в
массиве: 1и2,

3 и 4, 5 и
6 и т. д.

for(int i=0;i {int r=a[i];
a[i]=a[i+1];
a[i+1]=r;}

два массива из n целых элементов. Получить массив c,

где c[I]=a[I]+b[I].

For(int I=0;I

по своей схеме.
В массиве целых чисел все отрицательные элементы

перенести в начало массива.
int b[10];//вспомогательный массив
int i,j=0;
for(i=0;i if(a[i]<0){b[j]=a[i];j++;}//переписываем из а в b все отрицательные элементы
for(i=0;i if(a[i]>=0){b[j]=a[i];j++;}// переписываем из а в b все положительные элементы
for(i=0;i

cout

элемента К в массив целых чисел.
int k;
coutk;
int ok=0;//признак найден

элемент или нет
int i,nom;
for(i=0;i if(a[i]==k){ok=1;nom=i;break;}
if(ok==1)
cout<<"\nnom="< else
cout<<"\n there is no such element!";

объектов в некотором установленном порядке.

Простые методы подразделяются на три

основные категории:
- сортировка методом простого включения;
- сортировка методом простого выделения;
- сортировка методом простого обмена;

который будем вставлять
j=i-1;
while(x=0)//поиск подходящего места
{
a[j+1]=a[j];//сдвиг вправо
j--;
}
a[j+1]=x;//вставка

элемента
}