Способ: tmp=x[0]; x[0]=x[n-1]; x[n-1]=tmp;

1 способ: tmp=x[0]; x[0]=x[n-1]; x[n-1]=tmp;

2 способ: x[0]=x[0]+x[n-1]; x[n-1]=x[0]-x[n-1]; x[0]=x[0]-x[n-1];

Пример 2.2

Поменять местами заданный элемент массива x[k] с последующим.

Решение

При решении этой задачи необходимо учитывать, что если заданный элемент массива x[k] является последним, то обмен выполнить не возможно, поскольку последующий элемент отсутствует.

if(k == n-1) puts("Обмен не возможен."); else { tmp=x[k]; x[k]=x[k+1]; x[k+1]=tmp; }

Рисунок 2.4 Алгоритм и фрагмент программы перестановки заданного элемент массива x[k] с последующим

При перестановке с предыдущим элементом, обмен невозможен если заданный элемент является первым (k=0).

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

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

Пусть а[] – заданный массив из n элементов. Сумма всех его элементов в математической форме выглядит следующим образом:

(2.1)

Для вычисления суммы элементов части массива, например, с in–го до ik–го. Следует использовать формулу:

(2.2)

Очевидно, что формула (2.2) получается из формулы (2.1) при in=0 и ik=n–1.

Алгоритм вычисления суммы состоит в следующем:

1.  установить значение переменой для накопления суммы (s) в нулевое значение (s=0);

2.  в цикле изменяя i от in до ik вычислить суммуэлементов массива по выражениию s=s+a_i.

При первой итерации цикла (i=in) получим s=s+a_in= 0+ a_in. На второй (i=in+1) – s=s+a_in+1= a_in + a_in+1 и т. д. На последней итерации цикла будем иметь s=s+a_ik= a_in + a_in+1+…+ a_ik. Т.е. в цикле по параметру i "старое" значение s, содержащее накопленную сумму на предыдущей итерации, изменяется на значение a_i. На рисунке 2.5 представлен алгоритм и фрагменты программ вычисления суммы элементов массива.

*/вычисление суммы элементов массива с in по ik s=0; for(i=in;i<ik;i++) s=s+a[i]; // или s+=a[i]; или s+=*(a+i); */вычисление суммы всех элементов массива s=0; for(i=0;i<n;i++) s+=a[i];

Рисунок 2.5 Графическая схема и фрагмент программы вычисления суммы элементов массива

Если в алгоритме (рисунок 2.5) в блоке 2 записать i=0, а блоке 3 – (i<n), то получим алгоритм вычисления суммы всех элементов массива.

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

/* с помощью цикла for */ s=0; for(i=in;i<ik;i=i+step) s+=a[i]; // или s=s+a[i]; /* с помощью цикла while */ s=0; i=in; while (i<ik) { s+=a[i]; i=i+step; }

Рисунок 2.6 Графическая схема и фрагмент программы вычисления суммы элементов массива стоящих на заданных местах

Например, чтобы вычислить сумму элементов, стоящих в массиве на четных местах, необходимо "заставить" i принимать значения 1, 3, 5, … (поскольку нумерация элементов массива в С начинается с нуля т.е. элемент массива с индексом a[0] – первый элемент массива). Для этого достаточно в блоке 2 записать i=1, в блоке 3 – (i<n), а в блоке 5 записать i=i+2 (step=2). В программе на языке С соответствующий фрагмент будет выглядеть следующим образом:

s=0;

for(i=1;i<n;i=i+2) // или for(i=1;i<n;i+=2)

s+=a[i]; // или s=s+a[i];

Для вычисления суммы только тех элементов, которые удовлетворяют некоторому условию, необходимо в алгоритме вычисления суммы (рисунок 2.6) блок 4 заменить на ветвление, которое обеспечивает выполнение команды s=s+a_i только тогда, когда условие выполнено для рассматриваемого элемента массива a_i. В этом случаи алгоритм вычисления суммы примет следующий вид (рисунок 2.7).

/* с помощью цикла for */ s=0; for(i=in;i<ik;i+=step) if( условие ) s+=a[i]; // или s=s+a[i]; /* с помощью цикла while */ s=0; i=in; while (i<ik) { if( условие ) s+=a[i]; i=i+step; }

Рисунок 2.7 Графическая схема и фрагмент программы вычисления суммы элементов массива стоящих на заданных местах

Применим полученный алгоритм для вычисления суммы положительных элементов массива стоящих на нечетных местах. Для этого в блоке 2 запишем i=0, в блоке 3 (i<n), в 4 условие – (a[i]>0), а в блоке 6 изменение параметра цикла (step=2) i=i+2. Тогда соответствующий фрагмент программы можно записать в виде:

s=0;

for(i=0;i<n;i+=2)

if( a[i]>0 ) s+=a[i]; // или s=s+a[i];

Рассмотрим примеры использования рассмотренных алгоритмов.

Пример 2.3.

В одномерном массиве a размерностью n, вычислить сумму элементов массива, меньших заданного значения В и стоящих на местах, кратных трем.

Решение

Объединим алгоритмы ввода – вывода массива (рисунок 2.2) и вычисления суммы (рисунок 2.7). Для сокращения записи графической схемы алгоритма ввода и вывода массива, здесь и в дальнейшем используем простые блоки вида:

В алгоритме для вычисления искомой суммы рассматриваются только те элементы, которые в массиве стоят на местах, кратных трем, при этом необходимо учитывать что нумерация элементов массива в С начинается с нуля т.е. элемент массива с индексом a[0] это первый элемент массива. Таким образом, элементы стоящие на местах кратных трем – а₂, а₅, а₈, …, индекс элемента массива (он же – параметр цикла) должен последовательно принимать значения 2, 5, 8, …, т.е. изменяться от 2 с шагом 3, что и достигается изменениями в блоках 2 и 6 алгоритма вычисления суммы (рисунок 2.7). Так в блоке 2 запишем i=2, в блоке 3 (i<n), а в блоке 6 – (step=3) i=i+3. Для суммирования из рассмотренных элементов только тех, которые меньше заданного В, используется ветвление с условием а_i<В (блок 4). Окончательный алгоритм вычисления суммы заданных элементов примет, следующий вид (рисунок 2.8). В задаче будем использовать динамический способ задания массива. В данном примере для обращения к элементам массива используются указатели. Как уже отмечалось в разделе 1.1, имя массива является указателем на его первый элемент.

Используемые переменные:   n – число элементов массива; a[] – динамический массив; s – сумма элементов массива; B – заданное число; i – параметр цикла;

#include <stdio.h> main() { int n,i; float s, B; puts("Введите число элементов массива a"); scanf("%d",&n); float *a=new float[n]; for (i=0;i<n;i++) { printf("Введите число a[%2d]=",i); scanf("%f",a+i); } puts("Введите B");  scanf("%f",&B); s=0; for(i=2;i<n;i+=3) if(*(a+i)<B) s+=*(a+i); puts("Массив a"); for(i=0;i<n;i++) printf("%.1f ",*(a+i)); printf("\n"); printf("Сумма чисел, меньших %.1f,  стоящих на местах, кратных 3, равна %.2f\n",B,s); delete[] a; // освобождение памяти return(0); }

Рисунок 2.8 Графическая схема и программа примера 2.3

2.5 Подсчет количества элементов массива, удовлетворяющих заданному условию

Подсчет количества элементов массива, удовлетворяющих заданному условию, производится по алгоритмам, аналогичным вычислению суммы. Отличие заключается в том, что вместо добавления элемента массива к сумме, переменная – счетчик (k) увеличивается на единицу (k=k+1). Таким образом, если в графических схемах алгоритмов, рисунок 2.5–2.7, вместо s=0 и s=s+a_i записать k=0 и k=k+1, то получим алгоритмы подсчета количества элементов массива.

Пример 2.4.

В одномерном массиве a размерностью n, вычислить количество элементов равных заданному числу B и стоящих на четных местах.

Решение.

Графическая схема алгоритма решения задачи и фрагмент программы изображена на рисунке. 2.9.

/* с помощью цикла for */ k=0; for(i=1;i<n;i+=2) if(a[i]==b ) k++; // или k=k+1; /* с помощью цикла while */ k=0; i=1; while (i<n) { if(a[i]==b) k++; i=i+2; }

Рисунок 2.9 Графическая схема и программа для примера 2.4

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

Пример 2.5.

В одномерном массиве a размерностью n, вычислить среднее арифметическое положительных элементов второй половины массива, стоящих на нечетных местах.

Решение

Среднее арифметическое чисел (sr) – частное от деления их суммы (s) на их количество (k): sr=s/k, где k≠0. Таким образом, задача сводится к нахождению суммы и количества положительных элементов второй половины массива, стоящих на нечетных местах. Для решения данной задачи применим алгоритм, приведенный на рисунке 2.7, в соответствии с которым можно найти сумму и количество части элементов массива (второй половины), удовлетворяющих заданному условию (положительных элементов).

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

(2.3)

Значение ik совпадает с n, поскольку массив надо просматривать до конца. Параметр цикла i (номер элемента массива) необходимо изменять с шагом 2, чтобы обеспечить четные значения индекса (значения номеров элементов массива), т.е. i=i+2. Вычисление суммы и количества будем вычислять в одном цикле по параметру i, что значительно сократит алгоритм.

При вычислении среднего арифметического sr=s/k необходимо избежать возможного деления на ноль, поскольку если во второй половине массива на нечетных местах не окажется положительных элементов то k будет равным нулю. Например, для массива X={2, 0, –6, 7, 9, 0, –14, –5, 0, –4, –32}; n=11; in=[n/2]+1=6, в цикле по i будут просматриваться только выделенные элементы, а среди них нет положительных чисел, поэтому переменная k останется равной нулю. В графической схеме (рисунок 2.10) для этой цели используется ветвление, в котором проверяется условие k=0. Если это условие выполнено, то выводится сообщение о том, что среднее значение не может быть вычислено, в противном случае вычисляется и выводится значение sr.

В приведенном ниже фрагменте программы четность [n/2] определяется по остатку от деления n на 2 с помощью операции % – определения остатка целочисленного деления (примечание: результат операции целочисленный, т.к. n и 2 – целочисленные операнды).

Используемые переменные: n – число элементов массива; a[] – статический массив; in – первый четный номер второй половины массива; s – сумма элементов массива удовлетворяющих условию; k – количество элементов массива удовлетворяющих условию; sr – среднее значение элементов массива удовлетворяющих условию; i – параметр цикла;

#include <stdio.h> main() { float a[20]; int n, i , in, k; float s, sr; puts("Введите число элементов массива a"); scanf("%d",&n); for (i=0;i<n;i++) { printf("Введите число a[%2d]=",i); scanf("%f",&a[i]); } if ((n/2)%2==0) in=n/2; else in=n/2+1; s=0; k=0; for(i=in;i<n;i+=2) if(a[i]>0) { s+=a[i]; k++;} puts("Массив a"); for(i=0;i<n;i++) printf("a[%2d]=%6.2f \n", i, a[i]); if (k==0) puts("Среднее арифметическое вычислить нельзя!"); else {  sr=s/k;  printf("Среднее ариф. полож. элементов на нечетных. местах второй полов. массива =%6.3f\n", sr); } return(0); }

Рисунок 2.10 Графическая схема и программа для примера 2.5

2.6 Вычисление произведения элементов массива

Формулы, по которым вычисляется произведение элементов массива, аналогичны формулам вычисления сумм:

, (2.4)

. (2.5)

Поэтому вычисление произведения элементов массива выполнятся по алгоритмам аналогичным вычислению суммы. Отличие заключается в том, что начальное значение произведения p должно быть равным 1, а в цикле по параметру i надо вычислять p=p*a_i. Таким образом, если в графических схемах алгоритмов, рисунок 2.5 – 2.7 вместо s=0 и s=s+a_i записать p=1 и p=p*a_i, то получим алгоритмы вычисления произведения элементов массива.

Пример 2.6.

В одномерном массиве a размерностью n, вычислить среднее геометрическое ненулевых элементов массива.

Решение

Среднее геометрическое k элементов массива – это корень степени k из произведения этих элементов. Таким образом, сначала необходимо вычислить произведение Р ненулевых элементов массива и их количество k, а затем среднее геометрическое Sg по формуле:

. (2.6)

Например, если элементы массива равны A= {1, 0, 2, 4, 0} то –

Графическая схема алгоритма решения задачи изображена на рисунке 2.11. В приведенном алгоритме в цикле по i (блоки 5 – 9) помимо вычисления произведения вычисляется и количество ненулевых элементов массива. После цикла с помощью ветвления, проверяется, есть ли в массиве ненулевые элементы (k>0 – условие наличия в массиве ненулевых элементов), в этом случае вычисляется и выводится среднее геометрическое. В противном случае выводится сообщение "В массиве все элементы равны нулю". В программе переменные Р и Sg имеют вещественный тип двойной точности (double), т.к. произведение вещественных чисел может быть очень большим числом.

Используемые переменные:   n – число элементов массива; a[] – статический массив; P – произведение не нулевых элементов массива; k – количество не нулевых элементов массива; Sg – среднее геометрическое элементов массива; i – параметр цикла;

#include <stdio.h> #include <math.h> main() { float a[20]; int n, i , k; double P, Sg; puts("Введите число элементов массива a"); scanf("%d",&n); for (i=0;i<n;i++) { printf("Введите число a[%2d]=",i); scanf("%f",&a[i]); } P=1; k=0; for(i=0;i<n;i++) if(a[i]!=0) {P*=a[i]; k++;} puts("Массив a"); for(i=0;i<n;i++) printf("a[%2d]=%6.2f \n", i, a[i]); if(k>0) {  if(P>0) Sg=powl(P,1.0/k); else Sg= –powl(fabs(P),1.0/k); printf("Среднее геометрическое ненулевых элементов массива =%.4lf \n", Sg); printf("P=%.4lf k=%d \n", P, k); } else puts("В массиве все элементы равны нулю! "); return(0); }

Рисунок 2.11 Графическая схема и программа для примера 2.6

В программе для возведения P в степень 1/k используется функция powl(основание, степень), первый аргумент которой может быть только положительным числом. Поэтому для отрицательного P использовано выражение , запись которого на языке С имеет вид: –powl(fabs(P), 1.0/k).

2.7 Поиск элементов, обладающих заданным свойством

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

В таких случаях для просмотра массива обычно используется оператор цикла while со сложным условием. Графическая схема для рассматриваемого примера изображена на рисунке 2.12. После цикла достаточно проверить, чему равно i. Если окажется, что i=n, т.е. были просмотрены все элементы, то в массиве нет нулевых элементов.

i=0; while(i<n && a[i]!=0) i=i+1;   If(i == n)  puts("В массиве нет нулевых элементов"); else puts("В массиве есть нулевой элемент");

Рисунок 2.12 Графическая схема и фрагмент программы поиска нулевого элемента в массиве

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

i=n–1; while(i>=0 && a[i]!=0) i=i–1;   If(i<0) puts("В массиве нет нулевых элементов");  else printf("Индекс последнего нуля – %d \n", i);

Рисунок 2.13 Графическая схема и фрагмент программы поиска номера последнего нулевого элемента в массиве

Номер (индекс) первого встретившегося нулевого элемента можно узнать по значению параметра цикла i. Этот номер можно использовать в дальнейших вычислениях например как номер начального элемента для поиска максимума.

2.8 Поиск в упорядоченном массиве

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

(а)	(б)

Рисунок 2.14. Графический алгоритм обработки упорядоченного массива с перебором с начала (а), с конца (б)

Как видно из блок–схемы, дополнительное условие управляет досрочным выходом из цикла. Пока дополнительное условие истина и не конец массива i<n, цикл выполняется, как только одно из условий будет не выполнено происходит выход из цикла.

Пример 2.7

В возрастающем одномерном массиве X с количеством элементов n, определить есть ли число равное A и на какой позиции оно находится, если числа A нет определить место на котором оно должно находиться чтобы не нарушить упорядоченность массива.

Решение

В данной задаче обработку массива будем проводить с начала. Выход из цикла по дополнительному условию будет выполнен, если в массиве найден элемент больший либо равный A (k=1). Для индикации наличия в массиве элемента равного A, введем вспомогательную переменную f с начальным значением f=0. При обнаружении элемента A, переменная f=1. Для определения номера позиции числа A в массиве введем дополнительную переменную poz с начальным значением n, т.е. предполагая, что все элементы массива меньше A. При обнаружении в массиве числа большего или равного A в переменной poz сохраняется его индекс – i. После выхода из цикла, по значению переменной f определяется наличие и место переменной A в массиве. Описанный алгоритм поиска и программа представлены на рисунке 2.15.

Используемые переменные: n – число элементов массива; a[] – статический массив; k – переменная для досрочного выхода из цикла при нахождении элемента большего или равного a; f – вспомогательная переменная для индикации наличия в массиве числа равного a; poz – номер элемента массива на котором должно находится число a; i – параметр цикла;

#include <stdio.h> main() { int f, k, n, poz, i, x[10], a; puts("Введите число элементов массива:"); scanf("%d",&n); for(i=0;i<n;i++) { printf("x[%2d]=",i); scanf("%d",&x[i]); } puts("Введите число a:"); scanf("%d",&a); f=0; poz=n; k=0; for(i=0;i<n&&k==0;i++) { if(x[i]>a) { poz=i;k=1;} else { if(x[i]==a) {poz=i; f=1; k=1;} } } if(f==1) printf("В массиве есть число =%d, на позиции-%d\n", a, poz); else printf("Число %d должно находиться на позиции-%d\n" ,a, poz); for(i=0;i<n;i++) printf("x[%d]=%d\n",i,x[i]); return 0; }

Рисунок 2.15. Графический алгоритм и программа для примера 2.7

Описанный алгоритм можно дополнить предварительным сравнением последнего элемента массива X[n-1] с числом A, если X[n-1]=A – то заданное число находится на последнем месте, а в случаи выполнения X[n-1]>A – то, число A должно находится в массиве на позиции n. Если ни одно из этих условий не выполнено, то это означает что необходимо выполнить поиск числа A в массиве.