Использование массивов

Размещено на http://www.allbest.ru/

Тема 6. ИСПОЛЬЗОВАНИЕ МАССИВОВ

Зачем нужны массивы?

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

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

//Объявление и инициализации десяти переменных

int age_0 = 30; int age_1 = 21;

int age_2 = 22; int age_3 = 19;

int age_4 = 45; int age_5 = 18;

int age_6 = 15; int age_7 = 61;

int age_8 = 43; int age_9 = 39;

//Вычисление и вывод среднего

int sum = age_0 + age_1 + age_2 +

age_3 + age_4 + age_5 +

age_6 + age_7 + age_8 +

age_9;

float avg = (float) sum/10;

printf("Средний возраст равен %g лет\n", avg);

Как видно из представленного фрагмента кода, неудобство использования переменных заключается в том, что их пришлось объявить 10 штук и обработать 10 штук. Решить данную проблему при большем количестве переменных, скажем, при 1000, будет еще неудобнее. Кроме того, если в процессе написания программы количество требуемых переменных неизвестно, то придется существенно усложнять код.

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

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

Массив - это набор элементов, которые имеют одинаковый тип и хранятся в памяти строго последовательно. Обращение к элементу массива осуществляется по имени массива и номеру элемента в этом массиве. Номер элемента в массиве называется индексом. В языке Си индекс первого элемента равен 0, а индекс последнего - N-1, где N - это размер массива. При объявлении массива указывается тип его элементов, имя и размер:

<Тип> <Имя>[<Размер>];

В качестве типа элементов массива можно указывать любой существующий в языке Си тип. Имя массива следует выбирать, чтобы оно отражало суть содержимого массива. Например, абстрактный числовой массив можно назвать numbers, массив возрастов - ages, а массив весов - weights. Размер массива должен быть константой, а не переменной, поэтому существуют три способа объявления массива:

//Способ 1.

int numbers[10];

//Способ 2.

const int n = 10;

int numbers[n];

//Способ 3.

#define SIZE 10

int numbers[SIZE];

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

int size;

printf("Введите размер массива:\n");

scanf("%d", &size);

//Ошибка

int numbers[size];

Размер массива указывать необязательно, если при его объявлении выполняется инициализация:

int ages[] = {23, 45, 56, 78, 54};

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

numbers[0] = 99;

Кроме того, можно ввести значение элемента массива с клавиатуры при помощи функций ввода

scanf("%d", &numbers[1]);

symbols[7] = getchar();

или вывести на экран:

printf("%d", numbers[3]);

putchar(symbols[5]);

Работа с массивом заранее неизвестного размера

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

printf("Введите размер массива:\n");

scanf("%d", &size);

int numbers[size];

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

//Массив может хранить не более 100 элементов

int numbers[100];

//Вводим размер массива с клавиатуры

int size;

printf("Введите размер массива < 100:\n");

scanf("%d", &size);

//Заполняем массив случайными числами

for (int i=0; i<size; i++) {

numbers[i] = rand()%100;

}

//Выводим массив на экран

for (int i=0; i<size; i++) {

printf("%d ",numbers[i]);

}

Обратите внимание на то, что память выделена под 100 элементов, но фактически работа производится элементами, количество которых определено переменной size.

Сравнение и присваивание массивов

Массивы, в отличие от переменных, нельзя напрямую присвоить или сравнить. Это следует делать поэлементно, и для решения этой задачи лучше всего подходят циклы. Итак, для присвоения массива ages1 массиву ages2 следует использовать такую конструкцию:

for (int i=0; i<size; i++) {

ages2[i] = ages1[i];

}

Сравнение массивов нужно выполнять по аналогичной схеме:

bool equal = true;

for (int i=0; i<size; i++) {

if (ages1[i] != ages2[i]) {

equal = false;

break;

}

}

if (equal) {

printf("Массивы равны\n");

} else {

printf("Массивы не равны\n");

}

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

Вычисление суммы элементов массива

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

int sum = 0;

for (int i=0; i<size; i++) {

sum += numbers[i];

}

printf("Сумма равна %d\n", sum);

Подсчет количества элементов с нужным свойством

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

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

int n_elem = 0;

int sum = 0;

for (int i=0; i<size; i++) {

n_elem++;

sum += numbers[i];

}

printf("В массиве %d элементов\n", n_elem);

printf("Сумма равна %d\n", sum);

Конечно, значение переменной n_elem должно совпадать со значением size, поскольку данная программа складывает size единиц. Усложним задачу: подсчитаем количество элементов, которые больше 100. Для этого нужно в нашей сумме заменить единицы, соответствующие элементам меньшим 100, на нули:

int n_elem = 0;

for (int i=0; i<size; i++) {

if (numbers[i]>=100) {

n_elem+=1;

} else {

n_elem+=0;

}

}

printf("В массиве %d элементов\n", n_elem);

Очевидно, что операция ничего не дает, поэтому окончательный вариант программы выглядит так:

int n_elem = 0;

for (int i=0; i<size; i++) {

if (numbers[i]>=100) {

n_elem++;

}

}

printf("В массиве %d элементов\n", n_elem);

Поиск элемента в массиве

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

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

int find = 50;

for (int i=0; i<size; i++) {

if (find == numbers[i]) {

printf("Такой элемент есть в массиве\n");

} else {

printf("Такого элемента нет в массиве\n");

}

}

В данной реализации несколько ошибок. Подумайте, какие? Рассмотрим одну из них. Предположим, что элемента в массиве нет, тогда на каждой итерации цикла будет выполняться ветка else, и на экране появятся size сообщений о том, что элемента нет. Если же искомый элемент находится где-то в середине, что программа вначале выведет несколько сообщений об отсутствии, затем - одно сообщение о том, что элемент найден, а затем опять начнет сообщать, что элемента нет.

Что же делать? Нужно заметить два аспекта:

· если элемент найден, то поиск можно заканчивать;

· убедиться в отсутствии элемента можно лишь, пройдя весь массив.

Следующая программа учитывает эти аспекты:

//Искомый элемент

int isFound = 50;

//Нашли или нет

bool found = false;

for (int i=0; i<size; i++) {

if (find == numbers[i]) {

//Отмечаем, что элемент найден

isFound = true;

//Заканчиваем чикл

break;

}

}

//isFound эквивалентно isFound==true

if (isFound) {

printf("Такой элемент есть в массиве\n");

} else {

printf("Такого элемента нет в массиве\n");

}

Нахождение максимального элемента в массиве

Задача поиска «самого-самого» всегда актуальна. Кто из футболистов забил больше всего голов? У кого самая большая зарплата? Кто имеет максимальный рейтинг? Подобные вопросы возникают повсюду, но далеко не все представляют себе алгоритм нахождения этих «звезд». Мы изучим этот алгоритм на примере поиска максимального элемента в целочисленном массиве, а распространить его на перечисленные выше задачи не составит труда.

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

int max = numbers[0];

for (int i=1; i<size; i++) {

if (max < numbers[i]) {

max = numbers[i];

}

}

Заметим, что часто переменную max инициализируют не первым элементом, а некоторым «очень маленьким числом», а цикл начинают не с 1, а с 0. Подобный алгоритм выглядит так:

int max = -1000000;

for (int i=0; i<size; i++) {

if (max < numbers[i]) {

max = numbers[i];

}

}

Однако данный подход нежелателен, поскольку нет гарантии, что число меньше «очень маленького числа» не встретится, и, кроме того, выполняется одно лишнее сравнение. Полный пример поиска максимума выглядит так:

#define MAX_SIZE 100

int main() {

int numbers[MAX_SIZE];

printf("Введите размер массива: ");

int size;

scanf("%d", &size);

for (int i=0; i<size; i++) {

numbers[i] = rand()%100;

}

printf("Задан следующий массив:\n");

for (int i=0; i<size; i++) {

printf("%d ", numbers[i]);

}

printf("\n");

int max = numbers[0];

for (int i=1; i<size; i++) {

if (max < numbers[i]) {

max=numbers[i];

}

}

printf("Максимальный элемент = %d\n", max);

return 0;

}

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

int ind_max = 0;

for (int i=1; i<size; i++) {

if (numbers[ind_max] < numbers[i]) {

ind_max = i;

}

}

массив свойство элемент сортировка

Задача сортировки массива

Многие знакомы с задачей сортировки, и, вроде бы, всем понятно, что сортировать массивы нужно, однако на вопрос «Зачем это делать?» даст ответ не каждый. Подумайте, зачем сортировать массивы или списки. Представьте себе, если бы слова в словаре располагались бы не в алфавитном порядке, а в разброс; или товары в магазине не были бы разложены по типам, и разные марки колбасы находились бы по всему магазину.

Отсутствие порядка существенно затрудняет поиск. А как можно достичь порядка? Сортировкой. Именно облегчение последующего поиска является главной причиной, по которой производится сортировка. Существует масса методов, сортирующих массивы. Мы рассмотрим три наиболее простых для понимания и реализации метода: метод прямого выбора, метод пузырьковой сортировки и сортировку вставками. Метод прямого выбора - это наиболее очевидный для понимания способ сортировки массива, а пузырьковая сортировка - наиболее проста в реализации. Сортировка вставками довольно часто используется нами в жизни.

Сортировка методом прямого выбора

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

for (int i=0; i<size; i++) {

//Поиск минимального элемента

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

//i, i+1, i+2, ... , size

int j_min = i;

for (int j=i+1; j<size; j++) {

if (numbers[j_min] > numbers[j]) {

j_min = j;

}

}

 //Перестановка элементов

//с индексами i и j_max

int temp = numbers[i];

numbers[i] = numbers[j_min];

numbers[j_min] = temp;

}

Пузырьковая сортировка

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

for (int i=0; i<size-1; i++) {

for (int j=size-1; j>0; j--) {

//Сравниваем два соседних элемента

if (numbers[j-1] > numbers[j]) {

//Меняем их местами, если

//они стоят не в том порядке

int temp = numbers[j];

numbers[j] = numbers[j-1];

numbers[j-1] = temp;

}

}

}

Сортировка методом вставок

Сортировка методом вставок должна быть хорошо знакома людям, играющим в карты. Представьте себе, что вам раздали карты для игры. Карты следует расставить по старшинству: слева - старшие карты, а справа - младшие. Другими словами, задача заключается в том, чтобы отсортировать полученные карты в порядке убывания. Наши действия таковы:

· первую карту отодвигаем влево.

· берем вторую карту и ставим ее либо перед первой, либо после нее в зависимости от старшинства.

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

· действия продолжаем, пока не расставим все карты.

Отсюда и название метода - «Сортировка вставками». После очередной вставки отсортированная часть массива увеличивается на 1. Таким образом, программа имеет вид:

//Вставляем элементы, начиная со второго

for (int i=1; i<size; i++) {

<Вставить элемент с номером i

относительно элементов 0,…,i-1>

}

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

//Вставляем элементы, начиная со второго

for (int i=1; i<size; i++) {

 //Индекс вставляемого элемента

int j=i;

//Ищем позицию, куда вставить элемент

while (numbers[j]<numbers[j-1] && j!=0) {

//Меняем их местами, если

//они стоят не в том порядке

int temp = numbers[j];

numbers[j] = numbers[j-1];

numbers[j-1] = temp;

j--;

}

}

Двоичный поиск в упорядоченном массиве

Рассмотрим теперь, как реализовать быстрый поиск, используя упорядоченность массива; для определенности будем считать, что массив отсортирован по возрастанию. Главное свойство упорядоченного массива, позволяющее осуществить эффективный поиск, заключается в том, что, если искомый элемент меньше некоторого элемента массива, то можно отбросить расположенную справа от этого элемента часть массива и продолжать поиск только по левой части. Отсюда получается следующий алгоритм. Выбрать элемент, расположенный в середине массива, и сравнить искомый элемент с ним. Если элемент окажется меньше, то выбрать середину левой части и осуществлять деление до тех пор, пока не будет равенства или массив будет состоять из одного элемента. Если он не равен, то такого элемента нет в массиве.

printf("Введите искомый элемент: ");

int x;

scanf("%d",&x);

int left = 0;

int right = size-1;

bool found = false;

while (left<=right) {

int center = left + (right-left)/2;

if (x == numbers[center]) {

found = true;

break;

} else if (x < numbers[center]) {

right = center - 1;

} else {

left = center + 1;

}

}

if (found) {

printf("Элемент %d найден\n",x);

} else {

printf("Элемент %d не найден\n",x);

}

Многомерные массивы

Рассмотренные нами массивы являются одномерными, другими словами, каждый элемент в таких массивах определяется одним индексом. По аналогии можно вспомнить, что точка на прямой задается одной координатой. Прямая - это одномерное пространство. Существует также плоскость - двумерное пространство или даже трехмерное пространство. В математике вообще существуют пространства любой размерности. Аналогична ситуация и с массивами - они могут быть двумерными, трехмерными и так далее. Элементами одномерного массива являются элементы базовых типов, элементами двумерных массивов являются одномерные массивы, элементами трехмерных - двумерные и т.д. Следовательно, двумерный массив может рассматриваться как массив, элементы которого определяются двумя индексами, трехмерный - тремя и т.д. При объявлении многомерного массива нужно указать все его размеры, которые не обязательно должны быть одинаковыми:

int array_1d[100];

float array_2d[100][200];

char array_3d[100][200][50];

double array_4d[100][200][50][10];

unsigned short array_5d[100][200][50][10][30];

Обращение к элементам происходит так:

printf("%d", array_1d[i]);

printf("%f", array_2d[i][j]);

printf("%c", array_3d[i][j][k]);

printf("%e", array_4d[i][j][k][l]);

printf("%d", array_5d[i][j][k][l][m]);

Двумерные массивы - матрицы

Среди многомерных массивов наиболее часто используемым является двумерный массив, называемый по-другому матрицей. Матрицы широко используются в линейной алгебре, теории графов, вычислительных методах, математической статистике, физике, механике, а также во многих других фундаментальных и прикладных науках. Рассмотрим несколько задач, связанных с матрицами. Итак, первая задача - это объявление такого массива и заполнение его некоторыми значениями. В реальных задачах значения берутся реальные, которые, например, вводят операторы. У нас на это может не быть времени, поэтому самый быстрый и простой способ заполнения двумерного (да, и не только двумерного) массива - это заполнение случайными числами.

//Объявление массива

int matrix[100][100]

//Задание размера массива

int n;

printf("Введите размер массива:\n");

scanf("%d", &n);

//Заполнение массива случайными целыми числами

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

for (int j=0; j<n; j++) {

matrix[i][j] = rand()%1000;

}

}

Если нужно заполнить массив случайными вещественными числами, то можно использовать следующий прием:

· получить случайное число с помощью функции rand();

· взять его по модулю 10000, т.е. rand()%10000;

· получится целое число из диапазона от 0 до 9999;

· поделить это число на 100;

· получится число из диапазона от 0 до 99.99.

//Заполнение массива

//случайными вещественными числами

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

for (int j=0; j<n; j++) {

matrix[i][j] = (float) (rand()%10000)/100;

}

}

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

//Вывод матрицы на экран

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

for (int j=0; j<n; j++) {

printf("%5d", numbers[i][j]);

}

printf("\n");

}

Особенности обработки матриц

При обработке матриц нужно учитывать ряд особенностей, некоторые из которых мы рассмотрим на примерах. Рассмотрим задачу вывода элементов, расположенных на главной диагонали. Главная диагональ матрицы определяется тем, что на ней находятся элементы, оба индекса которых одинаковы: A1,1, A2,2, A3,3 и т.д. Способ, который может показаться наиболее очевидным - это проверить индексы массива на равенство:

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

for (int j=0; j<n; j++) {

if (i==j) {

printf("%d ", matrix[i][j]);

}

}

printf("\n");

}

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

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

printf("%5d\n", numbers[i][i]);

}

Такое усовершенствование не повлияет на результат, но сокращает объем программного кода и улучшает производительность.

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

//Переменная, которая будет хранить

//индекс столбца с максимальной суммой

int max_index = 0;

//Переменная, которая будет хранить

//максимальную среди всех столбцов сумму

int max_sum = 0;

//Пробегаем по всем столбцам

for (int j=0; j<n; j++) {

//Вычисляем сумму в столбце с индексом j

int sum = 0;

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

sum += numbers[i][j];

}

//Если полученная сумма больше,

//то переприсваиваем

if (sum > max_sum) {

max_sum = sum;

max_index = j;

}

}

printf("Макс. сумма равна %d\n", max_sum);

printf("Столбец с индексом %d\n", max_index);

Обработка данных «на лету»

Примеры решения задач

Задача 1. Написать программу, которая принимает с клавиатуры число N, задает массив из N случайных целых чисел и выводит его на экран. Затем необходимо вывести элементы этого массива, которые не принадлежат отрезку [5,15].

#include <stdio.h>

#include <stdlib.h>

int main() {

int N;

printf("Введите число N:\n");

scanf("%d", &N);

int numbers[100];

for (int i=0; i<N; i++) {

numbers[i] = rand()%50;

}

for (int i=0; i<N; i++) {

printf("%d ", numbers[i]);

}

printf("\nЭлементы из отрезка [5,15]:\n");

for (int i=0; i<N; i++) {

if (5<=numbers[i] && numbers[i]<=15) {

printf("%d ", numbers[i]);

}

}

printf("\n");

return 0;

}

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

#include <stdio.h>

#include <stdlib.h>

int main() {

int N;

printf("Введите число N:\n");

scanf("%d", &N);

int numbers[100];

for (int i=0; i<N; i++) {

numbers[i] = rand()%2000;

}

for (int i=0; i<N; i++) {

printf("%d ", numbers[i]);

}

printf("\n");

int digits3 = 0;

for (int i=0; i<N; i++) {

if (100<=numbers[i] && numbers[i]<=999) {

digits3++;

}

}

printf("Число трехзначных чисел = %d\n",

digits3);

return 0;

}

Задача 4. Написать программу, которая принимает с клавиатуры число N, задает массив из N случайных целых чисел и выводит его. Затем необходимо отсортировать его методом прямого выбора по убыванию.

#include <stdio.h>

#include <stdlib.h>

int main() {

int N;

printf("Введите число N:\n");

scanf("%d", &N);

int numbers[100];

for (int i=0; i<N; i++) {

numbers[i] = rand()%100;

}

printf("\nИсходный массив:\n");

for (int i=0; i<N; i++) {

printf("%d ", numbers[i]);

}

for (int i=0; i<N-1; i++) {

int max_index = i;

for (int j=i+1; j<N; j++) {

if (numbers[max_index]<numbers[j]) {

max_index = j;

}

}

int temp = numbers[i];

numbers[i] = numbers[max_index];

numbers[max_index] = temp;

}

printf("\nОтсортированный массив:\n");

for (int i=0; i<N; i++) {

printf("%d ", numbers[i]);

}

return 0;

}

Задача 4. След матрицы - это сумма ее диагональных элементов. Написать программу, которая вычисляет след матрицы.

#include <stdio.h>

#include <stdlib.h>

int main() {

int N;

printf("Введите число N:\n");

scanf("%d", &N);

int numbers[100][100];

for (int i=0; i<N; i++) {

for (int j=0; j<N; j++) {

numbers[i][j] = rand()%10;

}

}

printf("\nМатрица:\n");

for (int i=0; i<N; i++) {

for (int j=0; j<N; j++) {

printf("%d ", numbers[i][j]);

}

printf("\n");

}

int trace = 0;

for (int i=0; i<N; i++) {

trace += numbers[i][i];

}

printf("След матрицы равен %d\n", trace);

return 0;

}

ВОПРОСЫ ДЛЯ САМОПРОВЕРКИ

1. Объясните своими словами, зачем нужны массивы.

2. Опишите алгоритм поиска максимального (минимального) элемента в массиве.

3. Объясните своими словами, зачем сортировать данные.

4. Опишите алгоритм метода прямого выбора.

5. Опишите алгоритм пузырьковой сортировки.

6. Опишите алгоритм сортировки вставками.

7. Описать алгоритм последовательного поиска.

8. Опишите алгоритм двоичного поиска. Каким должен быть массив для его применения?

9. Как вывести матрицу на экран, чтобы столбцы были ровными.

10. Как вывести на экран диагональные элементы матрицы?

ТРЕНИРОВОЧНЫЕ ЗАДАНИЯ

1. Заполнить массив случайными числами и вывести его.

2. Вычислить сумму элементов массива.

3. Подсчитать количество четных элементов в массиве.

4. Заполнить матрицу случайными числами и вывести ее.

5. Найти максимальный (минимальный) элемент массива.

6. Заменить числом 10 все элементы массива большие 10.

7. Отсортировать массив.

8. Вывести элементы, которые расположены на главной и на побочной диагонали матрицы.

9. Подсчитать количество столбцов матрицы, сумма элементов которых не превосходит число 100.

10. Сложить две матрицы поэлементно.

Размещено на Allbest.ru