Как найти номер максимального элемента массива паскаль

Перейти к содержанию

const N = 10;

var

    arr: array[1..N] of integer;

    i, max: byte;

begin

    randomize;

    max := 1;

    for i:=1 to N do begin

        arr[i] := random(100);

        write(arr[i], ' ');

        if arr[max] < arr[i] then

            max := i;

    end;

    writeln;

    writeln('arr[',max,'] = ',arr[max]);

end.

64 26 99 37 57 64 6 21 48 19 

arr[3] = 99

#include < stdio.h>

#define N 10

main() {

    int arr[N], i, mx;

    srand(time(NULL));

    mx = 0;

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

        arr[i] = rand() % 100;

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

        if (arr[i] > arr[mx])

            mx = i;

    }

    printf("narr[%d] = %dn", mx, arr[mx]);

}

75 46 7 39 11 29 34 77 86 25 

arr[8] = 86

from random import random

N = 10

arr = [0] * N

mx = 0

for i in range(N):

    arr[i] = random() * 100

    print("%.2f" % arr[i], end='; ')

    if arr[i] > arr[mx]:

        mx = i

print("narr[%d] = %.2f" % (mx, arr[mx]))

73.83; 16.23; 30.18; 27.41; 94.27; 46.27; 66.17; 61.07; 18.89; 61.16; 

arr[4] = 94.27

алг

нач

  цел N = 10

  целтаб arr[1:N]

  цел mx, i

  mx := 1

  нц для i от 1 до N

    arr[i] := irnd(100)

    вывод arr[i], " "

    если arr[mx] < arr[i] то

      mx := i

    все

  кц

  вывод нс,"arr[",mx,"] = ",arr[mx]

кон

57 78 14 96 76 9 19 36 45 54 

arr[4] = 96

decimal 1

N = 10

dim arr(N)

mx = 0

for i=0 to N-1

	arr[i] = rand * 100

	print arr[i] + "; ";

	if arr[i] > arr[mx] then mx = i

next i

print

print "Номер элемента: " + mx

print "Значение элемента: " + arr[mx]

21.9; 58.4; 24.4; 72.6; 88.5; 65.2; 56.6; 65.1; 72.6; 40.4; 

Номер элемента: 4

Значение элемента: 88.5

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

Первое, что придётся сделать – создать массив. Как нам уже известно, нужно использовать цикл с параметром. Также удобнее будет создать массив случайным образом, если в условии задачи не оговорён способ задания массива.

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

Сначала указываем, что первый элемент массива считается максимальным, иначе говоря – Max = A[i].

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

Тут возможно два случая :

1. Если максимальный элемент больше следующего, то ничего не меняем.
2. Если максимальный элемент меньше следующего, то он становиться максимальным.

После этого выводим на экран максимальный элемент.

Блок-схема максимальный элемент массива

Программа максимальный элемент массива Pascal

Ниже представлен текст программы на языке Pascal, как найти максимальный элемент массива. Как было указанно в алгоритме выше, сначала создается сам массив (в моем случает любые целые числа от 0 до 100 включительно).

Program Max_element_massiva ;
Var i, n, max : integer ;
    A : array [1..100] of integer;
Begin
     Writeln('Введите количество элементов массива') ;
     Readln(N) ;
     Randomize;
     For i := 1 to N do
          begin
               A[i] := Random(100);
               Write(A[i]);
          end;
     Max := A[1];
     For i := 2 to N do
          if A[i]>Max then Max := A[i];
     Writeln('Максимальный Элемент массива = ',Max) ;
     Readln ;
End.

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

Нахождение суммы и произведения элементов массива аналогичны алгоритмам нахождения суммы и произведения элементов последовательности.

Дан массив X, состоящий из n элементов. Найти сумму элементов этого массива. Переменной S присваивается значение, равное нулю, затем последовательно суммируются элементы массива X. Блок-схема алгоритма расчёта суммы приведена на рис. 5.19.

Соответствующий алгоритму фрагмент программы будет иметь вид:

s : = 0;
for i :=1 to n do
s := s+x [ i ];
writeln ( ’ s= ’, s : 7 : 3 );

Найдём произведение элементов массива X. Решение задачи сводится к тому, что значение переменной Р, в которую предварительно была записана единица, последовательно умножается на значение i-го элемента массива. Блок-схема алгоритма приведена на рис. 5.20.

Соответствующий фрагмент программы будет иметь вид:

p : = 1;
for i :=1 to n do
p:=p * x [ i ];
writeln ( ’P= ’,P : 7 : 3 );

5.6 Поиск максимального элемента в массиве и его номера

Рассмотрим задачу поиска максимального элемента (Max) и его номера (Nmax) в массиве X, состоящем из n элементов.

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

Соответствующий фрагмент программы имеет вид:

Max:=X [ 1 ];
Nmax: = 1;
for i :=2 to n do
if X[ i ]>Max then
begin
Max:=X[ i ];
Nmax:= i;
end;
write ( ’  Max= ’,Max : 1 : 3, ’  Nmax= ’,Nmax );

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

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

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

и в порядке убывания, если

Многие алгоритмы сортировки основаны на том факте, что переставлять два элемента надо таким образом, чтобы после перестановки они были правильно расположены друг относительно друга. При сортировке по возрастанию после перестановки элемент с меньшим индексом должен быть не больше элемента с большим
индексом^{2При сортировке по убыванию после перестановки элемент с меньшим индексом должен быть не меньше элемента с большим индексом.}. Рассмотрим некоторые из алгоритмов.

5.7.1 Сортировка методом «пузырька»

Наиболее известным методом сортировки является сортировка массивов пузырьковым методом. Её популярность объясняется запоминающимся
названием^{3Название алгоритма объясняется его сходством с процессом движения пузырьков в резервуаре с водой, когда каждый пузырёк находит свой собственный уровень.} и простотой алгоритма. Сортировкаметодом «пузырька» основана на выполнении в цикле операций сравнения и при необходимости обмена соседних элементов. Рассмотрим алгоритм пузырьковой сортировки на примере сортировки по возрастанию более подробно.

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

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

В табл. 5.8 подробно показан процесс упорядочения элементов в массиве.

Нетрудно заметить, что для преобразования массива, состоящего из элементов, необходимо просмотреть его раз, каждый раз уменьшая диапазон просмотра на один элемент. Блок-схема описанного алгоритма приведена на рис. 5.22. Для обмена двух элементов в массиве (блок 4) используется буферная переменная , в которой временно хранится значение элемента, подлежащего замене.

Ниже приведён текст консольного приложения, предназначенного для упорядочения массива по возрастанию методом пузырька.

program upor_massiv;
var i, j, n : byte;
	X: array [ 1.. 100 ] of real;
	b : real;
begin
writeln ( ’введите размер массива ’ );
	readln ( n );
for i :=1 to n do
begin
write ( ’X[ ’, i, ’ ]= ’ );
readln (X[ i ] );
end;
writeln ( ’массив X  ’ );
for i :=1 to n do write ( x [ i ] : 5 : 2, ’   ’ );
writeln;
for j :=1 to n-1 do
for i :=1 to n-j do
		if X[ i ] > X[ i +1] then
	{Если текущий элемент больше следующего, то}
		begin {поменять их местами.}
			b:=X[ i ]; {Сохранить значение текущего элемента.}
			X[ i ] : =X[ i + 1 ]; {Заменить текущий элемент следующим.}
			X[ i +1]:=b; {Заменить следующий элемент переменной b.}
		end;
writeln ( ’упорядоченный массив ’ );
for i :=1 to n do
	write (X[ i ] : 5 : 2, ’   ’ );
writeln;
end.

На рис. 5.23 приведены результаты работы этой программы.

Для упорядочения элементов в массиве по убыванию их значений необходимо при сравнении элементов массива заменить знак > на < (см. блок 3 на рис. 5.22).

Рассмотрим следующий алгоритм сортировки.

5.7.2 Сортировка выбором

Для сортировки элементов массива по возрастанию (по убыванию) можно воспользоваться алгоритмом сортировки выбора максимального (минимального) элемента. Алгоритм выбором приведён в виде блок-схемы на рис. 5.24.

Найдём в массиве самый большой элемент (блоки 2—5) и поменяем его местами с последним элементом (блок 6). После этого максимальный элемент встанет на своё место. Теперь надо повторять эти действия (блоки 2—6), уменьшив количество просматриваемых элементов на единицу (блок 7) до тех пор, пока количество рассматриваемых элементов не станет равным одному (блок 8). В связи с тем, что мы на каждом шаге уменьшаем количество элементов на 1, то, чтобы не потерять размер массива (N), необходимо в начале алгоритма переписать N в переменную K (блок 1) и уменьшать уже значение K.

При упорядочении массива по убыванию необходимо перемещать минимальный элемент. Для этого в алгоритме (рис. 5.24) в блоке 4 достаточно поменять знак > на знак <.

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

k:=n;
repeat
max:=x [ 1 ];
nom: = 1;
for i :=2 to k do
if max < X[ i ] then
begin
max:=X[ i ];
nom:= i;
end;
b:=x [ nom ]; x [ nom] : = x [ k ]; x [ k ] : = b;
k:=k -1;
until k=1;

Следующим важным алгоритмом обработки массивов является алгоритм удаления элемента из массива.

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

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

program massiv5;
uses crt;
const N=10;
type x=array [1..N] of integer;
var a:x;
i:integer;
max:integer;
imax:integer;
begin
clrscr;
randomize;
for i:=1 to N do
begin
a[i]:= -50+random(101);
write (A[i]:5)
end;
writeln;
imax:=1;
max:=A[1];
for i:=2 to N do
if max<a[i] then
begin
max:=a[i];
imax:=i
end;
writeln (‘Максимальный элемент в массиве=’,max:5);
writeln (‘Его индекс=’,imax:5);
readln
end.

В строке №7 записываем переменную для хранения величины максимального элемента.

В строке №8 записываем переменную для хранения индекса максимального элемента.

В строке №11 мы включаем функцию Randomize. Эта функция позволяет генерировать случайные числа в программе. В данном случае нам необходимо каждому элементу массива [1..N] (всего 10 элементов) присвоить какое-нибудь значение. В программе «massiv3» значения для всех элементов массива мы вводили с клавиатуры. В этой задаче мы ничего вводить не будем. Функция Randomize сама создаст значения для каждого элемента массива. В массиве у нас 10 элементов ([1..N], const N=10), соответственно будет сгенерировано 10 случайных чисел.

В строке №12 включаем цикл. Переменная «I» будет изменяться в цикле от 1 до «N»

В строке №14 очередному элементу массива мы присваиваем случайное число, которое лежит в диапазоне от – 50 до + 50. (Сначала пишется минимальное число – 50, затем знак +, затем слово RANDOM, затем в скобках указывается общее количество возможных чисел в диапазоне; в диапазоне от – 50 до + 50 получается 100 чисел + число  0, всего 101)
Строка №15. Если мы запустим программу на данном этапе, у нас выведется на экран 10 различных чисел со значением от – 50 до + 50.

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

В строке №19 в переменную для хранения величины максимального элемента записываем значение первого элемента массива (например, если первое сгенерированное число будет 13, то его и будем считать максимальным).

В строке №20 задаем цикл. В него мы не включаем 1-ый элемент. А затем, в строке №21 мы проверяем условие. Мы сравниваем все значения элементов  массива (т.е. все сгенерированные числа) начиная со 2-го и до 10-го с  1 — ым числом. И если очередное число в массиве больше чем 1-ое число, то в переменную для хранения максимального числа записываем это очередное число (строка  №23), а в переменную для хранения индекса максимального числа записываем индекс этого очередного числа. После выполнения цикла в переменной max должно остаться максимальное число, а в переменной «imax» должен остаться номер этого числа.

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

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

program massiv5;
uses crt;
const N=10;
type x=array [1..N] of integer;
var a:x;
i:integer;
max:integer;
imax:integer;
begin
clrscr;
randomize;
for i:=1 to N do
begin
a[i]:= -5+random(3);
write (A[i]:5)
end;
writeln;
imax:=1;
max:=A[1];
for i:=2 to N do
if max<a[i] then
begin
max:=a[i];
imax:=i;
end;
writeln('Максимальный элемент в массиве=',max);
write('Его индекс ');
for i:=1 to N do
if max=a[i] then
begin
write (i,', ');
end;
readln
end.

Предыдущая статья : Randomize и Random в Pascal.

Оглавление : Уроки Паскаль.

Следующая статья : Вычисление суммы положительных элементов массива.

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

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

Рис.5 Нахождения
максимального элемента массива и его
номера

Соответствующий
участок программы будет иметь вид:

const
n=10;

var
x: array
[1..n] of
integer;

i, Max, NMax : integer;

begin

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

Max:=X[1];

Nmax:=1;

for
i:=2 to
N do

if
X[i]>Max then

begin

Max:=X[i];

Nmax:=i;

end;

writeln(‘Max = ‘,Max,’
Max position = ‘, Nmax);

В данном
примере можно обойтись одной переменной
Nmax, т.к. зная позицию
максимального элемента, мы знаем и его
значение. Тогда код можно переписать
так

Nmax:=1;

for
i:=2 to
N do

if
X[i]>X[NMax] then

Nmax:=i;

writeln(‘Max = ‘,X[NMax],’
Max position = ‘, Nmax);

Упорядочивание массива по возрастанию

Решим следующую задачу: задан массив
из nцелых чисел, упорядочить
массив по возрастанию. Блок-схема
представлена на рис.6. Алгоритм
упорядочивания состоит в следующем.
Сравниваем текущий и последующий
элементы массива, если текущий больше
последующего, то меняем их местами. В
результате этих действий самый большой
элемент станет на последнее место, т.е.
наN-е. Теперь повторяем
этот алгоритм дляN-1
элемента массива и устанавливаем
максимальный элемент на (N-1)-е
место. Так повторяем до тех пор, пока не
упорядочим весь массив. Для упорядочивания
по убыванию необходимо при сравнении
элементов массива заменить знак “больше”
на знак “меньше”. Такой метод получил
название пузырьковой сортировки.

Рис.6. Алгоритм
упорядочивания массива

Пример программы
упорядочивания массива (пузырьковая
сортировка).

const
n=10;

var 
i,j,b: integer;

y:
array
[1..n] of
integer;

begin

for
i:=1 to
n do
//ввод
элементов массива

    begin

        write(‘y[‘,i’]=’);
 readln (y[i]);

    end;

writeln
(‘массив
y ‘);

for
i:=1 to
n do

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

write (y [i],’
‘); 

writeln;

for
j:=1 to
n-1 do

for
i:=1 to
n-j do

        if 
y[i] > y[i+1]  then

           
begin
//
Меняем
элементы местами

               
b:=y[i];

               
y[i]:=y[i+1];

               
y[i+1]:=b;

           
end;

writeln(‘упорядоченный
массив‘);

for
i:=1 to
n do
 

write (y[i],’
‘); 

writeln;

end.

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

const
n=10;

var 
i,j,x,k: integer;

M:
array
[1..n] of
integer;

{x-значение
минимального элемента, k—
позиция минимального элемента}

begin

………

For
I:=1 to
N-1 do

begin

k:=i;{запоминаем
начальную позицию и первое значение
минимума}

X:=M[i];

For
J:=i+1
to
n
do
{поиск
нового минимального значения}

If
M[j] < x then

begin

k:=j;

x:=M[k];

end;

If
i<>k then
begin

M[k]:=M[i];{меняем
местами i-й
и минимальный k-й}

M[i]:=x;
end;

end;

……

end.