4. Задания

1. Проверить, можно ли получить последовательность значений элементов заданного массива a[1..n] из последовательности значений элементов другого заданного массива b[1..m] “вычеркиванием” некоторых элементов второй последовательности.

2. Проверить выполнение следующего свойства массивов a[1..n] и b[1..m]: для каждого элемента a[i] (i = 1...n) найдется равный ему элемент массива b.

3. Проверить выполнение следующего свойства упорядоченных по возрастанию массивов a[1..n] и b[1..m]: для каждого элемента a[i] (i = 1...n) найдется равный ему элемент массива b.

4. Даны 2 упорядоченных массива: a[1..n] и b[1..m]. Известно, что среди элементов этих массивов нет совпадающих. Найти количество элементов, встречающихся как в a, так и в b.

5. Рассматривая массивы a[1..n] и b[1..m] как последовательности цифр десятичной записи некоторых неотрицательных чисел, получить c[1..k] – аналогичное представление для суммы этих двух чисел.

5. Простые алгоритмы сортировки одномерных массивов

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

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

Суть метода состоит в том, что надо найти максимальный элемент массива и обменять его с первым элементом (с номером 1). Потом находят максимум среди элементов со второго до последнего и меняют его со 2-м элементом и т. д. В итоге, надо найти N – 1 максимум. Можно искать не максимум, а минимум и ставить его на последнее, предпоследнее и т. д. место. Также применяют модификацию этого метода с одновременным поиском максимума и минимума. В этом случае количество шагов поиска составляет N div 2.

Вычислительная сложность сортировки выбором – величина порядка N², так как количество сравнений при поиске первого максимума равно N – 1, затем N – 2, N – 3, и т. д. до 1, а в итоге N(N – 1)/2.

program Sort;

type Array1 = array[1..100] of Integer;

var Massiv : Array1; N, i : Integer;

procedure Sort1_1( var A : Array1; N : Integer);

{ Выбором максимального элемента;

входной параметр: N; транзитный параметр: A }

var i, k, m, x : Integer;

begin

for k := 1 to N-1 do { k - номер элемента, с которого поиск max }

begin

m := k; { m - номер max }

for i := k+1 to N do if A[i] > A[m] then m := i;

{ меняем местами элементы с номерами m и k }

x := A[m]; A[m] := A[k]; A[k] := x

end;

end;

begin

Write('Количество элементов массива: '); ReadLn(N);

for i := 1 to N do Read(Massiv[i]);

Sort1_1( Massiv, N);

for i := 1 to N do Write(Massiv[i],' ') {упорядоченный массив}

end.

Модификация процедуры сортировки выбором:

procedure Sort1_2( var A : Array1; N : Integer);

{ Выбором максимального и минимального элементов;

входной параметр: N; транзитный параметр: A }

var i, k, m, x, p : Integer;

begin

for k:=1 to N div 2 do { k - номер пары max и min }

begin

m:=k; { m - номер max } p:=k; { p - номер min }

{ max и min ищутся среди элементов с k до N-k+1 }

for i := k+1 to N-k+1 do

if A[i] > A[m] then m:=i

else if A[i] < A[p] then p:=i;

{ меняем местами элементы с номерами m и k }

x := A[m]; A[m] := A[k]; A[k] := x;

if p = k then p := m;

{ если min стоял на месте k, то сейчас он на месте m }

{ меняем местами элементы с номерами p и N-k+1 }

x := A[p]; A[p] := A[N-k+1]; A[N-k+1] := x

end;

end;

Сортировка обменом (методом “пузырька”)

Метод заключается в том, что, начиная с последнего элемента, последовательно сравниваются пары соседних элементов массива. Если они не упорядочены, то обмениваем местами пару соседних элементов. После одного такого прохода на первом месте будет максимальный элемент (“всплыл” первый “пузырек”). Затем надо рассматривать элементы от последнего до второго и т. д. Всего потребуется N – 1 проход. Вычислительная сложность сортировки обменом порядка N².

procedure Sort2_1( var A : Array1; N : Integer);

{ Обменная сортировка. Базовый вариант.

входной параметр: N

транзитный параметр: A }

var i, k, x : Integer;

begin

for k := 2 to N do { надо выполнить N-k+1 сравнений }

for i := N downto k do

if A[i] > A[i-1] then {меняем местами соседние элементы}

begin x := A[i]; A[i] := A[i-1]; A[i-1] := x end;

end;

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

procedure Sort2_2( var A : Array1; N : Integer);

{ Обменная сортировка. Проверка перестановок.

входной параметр: N

транзитный параметр: A }

var i, k, x : Integer; p:boolean;

begin

k := 2; { номер элемента, до которого первый проход }

p := true; { логическая переменная p истинна, если были

перестановки, т. е. нужно продолжать сортировку }

while p do

begin p := false; { начало нового прохода, перестановок еще не было }

for i := N downto k do

if A[i] > A[i-1] then

begin { меняем элементы местами }

x := A[i]; A[i] := A[i-1]; A[i-1] := x;

p:=true; { и запоминаем факт перестановки }

end;

k := k+1; { уменьшаем количество пар для следующего прохода }

end;

end;

Дополнительно можно запоминать место последней перестановки. Если при очередном проходе последней парой элементов, которые поменялись местами, были A[j] и A[j-1], то элементы массива с первого до (j – 1)-го уже стоят на своих местах. В итоге можно уменьшить количество проверяемых пар до j-го элемента включительно.

procedure Sort2_3( var A : Array1; N : Integer);

{ Обменная сортировка. Последняя перестановка.

входной параметр: N

транзитный параметр: A }

var i, k, x, m : Integer;

begin

Write('Количество элементов массива '); ReadLn(N);

for i := 1 to N do Read(A[i]);

k := 2; { номер элемента, до которого первый проход }

while k > 0 do

begin

m := 0; { пока перестановок при проходе нет, номер равен 0 }

for i := N downto k do

if A[i] > A[i-1] then

begin { меняем элементы местами }

x := A[i]; A[i] := A[i-1]; A[i-1] := x;

m := i+1; { и запоминаем место перестановки }

end;

k := m { количество пар зависит от места последней перестановки }

end;

for i:=1 to N do Write(A[i],' ') {упорядоченный массив}

end;