Программирование

3.2 Обработка массивов и матриц

Octave содержит достаточное количество операций предназначенных для работы с векторами и матрицами (см. гл. 6). В этом параграфе мы остановимся на поэлементной обработке одномерных и двумерных массивов.

Ввод массивов и матриц следует организовывать поэлементно, например так:

	
N = input(’N = ’); % Ввод элементов массива
for i =1:N
	x(i) = input(strcat(’x(’, int2str(i), ’)= ’ ));
end
% Результат работы программы
N = 5
x(1)= 1
x(2)= 2
x(3)= 3
x(4)= 4
x(5)= 5
% Ввод элементов матрицы
N = input(’N= ’); M =input(’M= ’);
for i =1:N
	for j =1:M
		a (i,j)=input(strcat( ’a(’, int2str(i), ’,’, int2str(j), ’)= ’ ));
	end
end
% Результат работы программы
N= 3
M= 3
a(1, 1)= 1
a(1, 2)= 2
a(1, 3)= 3
a(2, 1)= 4
a(2, 2)= 5
a(2, 3)= 6
a(3, 1)= 7
a(3, 2)= 8
a(3, 3)= 9

Для вывода приглашений вида и в функции использовались функции работы со строками: и int2str(d). Функция предназначена для объединения строк в одну строку, которая и возвращается в качестве результата. Функция преобразовывает число в строку символов.

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

	
s =0;
for i =1:N
	s=s+x(i);
end

При нахождении суммы элементов матрицы последовательно суммируют элементы всех строк.

	
s =0;
for i =1:N
	for j =1:M
		s=s+a(i, j);
	end
end

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

	
p=1;
for i =1:N
	p=p*x(i);
end

При вычислении произведения элементов матрицы последовательно перемножают элементы всех строк.

	
p=1;
for i =1:N
	for j =1:M
		p=p*a(i, j);
	end
end

Алгоритм решения задачи поиска максимума и его номера в массиве следующий. Пусть в переменной с именем хранится значение максимального элемента массива, а в переменной с именем — его номер. Предположим, что первый элемент массива является максимальным и запишем его в переменную , а в — его номер (то есть 1). Затем все элементы, начиная со второго, сравниваем в цикле с максимальным. Если текущий элемент массива оказывается больше максимального, то записываем его в переменную , а в переменную — текущее значение индекса .

Ниже представлен фрагмент программы поиска максимума.

	
Max=a ( 1 );
Nmax=1;
for i =1:N
	if x(i)>Max
		Max=x(i);
		Nmax=i;
	end;
end;

Алгоритм поиска минимального элемента в массиве будет отличаться от приведённого выше лишь тем, что в конструкции if текста программы знак поменяется с "больше" (>) на "меньше" (<).

Ниже приведён фрагмент программы, реализующий алгоритм поиска минимального элемента матрицы и его индексов.

	
Min=a(1, 1);
Nmin=1;
Lmin=1;
for i =1:N
	for j =1:M
		if a(i, j)<Min
			Min=a(i, j);
			Nmin=i;
			Lmin=j;
		end;
	end;
end;

Сортировка представляет собой процесс упорядочения элементов в массиве в порядке возрастания или убывания их значений.

Рассмотрим наиболее известный алгоритм сортировки методом пузырька. Сравним первый элемент массива со вторым, если первый окажется больше второго, то поменяем их местами. Те же действия выполним для второго и третьего, третьего и четвёртого, -го и -го, -го и -го элементов. В результате этих действий самый большой элемент станет на последнее -е место. Теперь повторим данный алгоритм сначала, но последний -й элемент рассматривать не будем, так как он уже занял своё место. После проведения данной операции самый большой элемент оставшегося массива станет на -е место. Так повторяем до тех пор, пока не упорядочим по возрастанию весь массив. Фрагмент программы сортировки элементов массива по убыванию приведён ниже.

	
for i =1:N-1
	for j =1:N-i
	if x(j)>x(j +1)
		b=x(j);
		x(j)=x(j +1);
		x(j +1)=b;
		end;
	end;
end;

Для сортировки по убыванию нужно в операторе if заменить знак "больше" (>) на "меньше" (<).

Рассмотрим удаление элемента из массива. Пусть необходимо удалить из массива , состоящего из n элементов, -й по номеру элемент. Для этого достаточно записать элемент на место элемента — на место и т.д., n — на место и при дальнейшей работе с этим массивом использовать -й элемент. Ниже приведён фрагмент программы, реализующей этот алгоритм.

	
for i=m:1:n-1
	x(i)=x(i+1);
end;

В Octave есть встроенные функции вычисления суммы , произведения элементов массива (матрицы), поиска максимума и минимума , сортировки , но лишь понимание алгоритмов работы функций позволит решать нестандартные задачи обработки массивов и матриц. Рассмотрим решение нескольких практических задач.

Пример 3.8. Найти наименьшее простое число в массиве , если таких чисел несколько, определите их количество.

Листинг 3.8 содержит программу решения этой задачи с подробными комментариями.

	
N = input(’N= ’); % Ввод размера массива.
for i =1:N % Цикл для ввода элементов массива.
	x(i)=input(strcat(’x(’, int2str(i), ’)= ’ ) );
end
pr = 0; % Если pr=0 —простых чисел нет, pr =1, простые числа есть.
for i = 1:N
% Переменная L используется при проверке является ли данный элемент
% массива x(i) простым числом, L = 1, пока не встретились делители числа,
	L=1; % L станет равным 0, если встретятся делители числа.
	for j =2:x(i) /2 % Цикл по j от 2 до x(i) /2 для проверки является ли
						% число простым (поиск возможных делителей числа).
			if mod(x(i), j )==0 % Если x(i) делится на j, то встретился
					L=0; % делитель числа, x(i) не является простым, L = 0 и
					break; % выходим из цикла по j с помощью оператора break.
			end;
	end;
	% Проверяем значение переменной L,
	if L==1 % если L = 1, то число x(i) — простое.
			if pr==0 % Если при этом pr = 0, то это означает, что встретилось
							% первое простое число
				Min=x(i); % записываем в переменную Min, т.е. предполагаем,
							% что x(i) и является минимальным простым
				k=1; % количество минимумов равно 1,
				pr =1;% записываем в pr 1, т.к. в массиве есть простые числа.
			else % Иначе, если pr =1, т.е. встретилось очередное
					% (не первое) простое число,
					if x(i)<Min % сравниваем x(i) с Min, если x(i)<Min,
							Min=x(i); % этот элемент записываем в переменную Min,
							k=1; % количество минимумов равно 1.
					else
							if x(i)==Min % Если очередной элемент x(i) равен Min,
									k=k+1; % то количество минимумов увеличивается.
							end;
					end;
			end;
	end;
end;
if pr == 0 % Если после перебора всех элементов массива, переменная pr
			% осталась равной 0 (простых чисел нет),
	disp ( ’Простых чисел нет!!!!’ ) % то вывод соответствующего сообщения.
else % Если были простые числа,
	disp(Min); % то вывод min (минимальное простое число)
	disp(k); % и k (количество минимумов)
end;

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

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

Листинг 3.9 содержит текст программы для решения поставленной задачи.

	
N=input(’N=’); % Ввод размера квадратной матрицы.
for i =1:N % Ввод квадратной матрицы.
	for j =1:N
			A(i, j)=input(strcat(’a(’, int2str(i), ’,’, int2str(j), ’)=
			’ ) );
	end
end
for j =1:N % Цикл по всем столбцам матрицы, в каждом из которых ищем
			% максимальный элемент и его номер.
	Max=A(1, j ); % Предполагаем, что первый элемент в столбце
							% является максимальным,
	nmax=1; % В переменную nmax, в которой будет храниться номер
				% максимального элемента j -го столбца записываем 1.
	for i =2:N % В цикле по i перебираем все элементы j _го столбца.
			if A(i, j)>Max % Если очередной элемент больше Max,
					Max=A(i, j); % то в переменную Max записываем его,
					nmax=i; % а в переменную nmax — его номер строки.
			end;
	end;
	if nmax==N+1-j % Если в текущем столбце максимальный элемент
							% находится на побочной диагонали,
			for i =1:N % то обнуляем все элементы в этом столбце.
				A(i, j) =0;
			end;
	end;
end;