Основы алгоритмизации и программирования. Часть вторая. Типовые алгоритмы обработки массивов. Асламова В.С - 6 стр.

UptoLike

Составители: 

11
Пример 2 Циклический сдвиг элементов массива влево
Организовать циклический сдвиг элементов массива A на m
позиций влево, при этом m элементов из конца массива перемещается в
начало. Массив состоит из n элементов.
Циклический сдвиг будем организовывать с помощью
вспомогательной переменной P. Во вспомогательную переменную каждый
раз пересылается последний элемент массива A, затем все элементы
сдвигаются влево на одн
у
позицию (в обратном порядке) и
на место первого элемента
помещается содержимое
вспомогательной переменной.
Эта процедура повторяется m
раз. Такой вариант сдвига
требует больших затрат времени
на многократное перемещение
элементов массива.
Программа 2
Var n, m, i, k: byte;
A: array[1 . . 50] of real;
P: real;
begin write('Ввод n, m');
readln(n,m);
writeln('Ввод ',n,'элементов');
for i:=1 to n do read(A[ i ]);
for i:=1 to m do begin
P:=A[ 1 ];
For k:=2 to n do
A[k1]:=A[ k ];
A[ n ]:=P end;
writeln; writeln('преобразованный
массив');
for i:=1 to n do write(A[ i ]:8:3);
writeln End.
НАЧАЛО
P:=A[ 1 ]
КОНЕЦ
Печать
Массив
A[ n ]:=P
П
ечать
Ввод n,m
П
ечать
Ввод A[ i ]
i:=1..n
i:=1..m
k:=2..n
A
[k–1]:=A[k
]
Экран
A[ i ]
i:=1..n
Рисунок 4. Подробный Блок-схема
программы 2
12
НАЧАЛО
Печать
Ввод n,m,
A[ i ]
КОНЕЦ
Печать
Массив
П
ечать
Ввод A[ i ]
i:=1..n
Печать
A[ i ]
i:=1..n
P[ i ]:=A[ i ]
i:=1..m
A[i–m]:=A[ i]
i:=m+1..n
A
[ i ]:= P[ i –n+m]
i:=n–m+1..
n
Ввод массива
Запись первых m
элементов в P[ i ]
Сдвиг всех
элементов на m
позиций влево,
начиная с m+1
Перепись массива P
вхвостмассива A
Печать массива A
Пример 3 Циклический сдвиг элементов массива влево
Организовать циклический сдвиг элементов массива A на m
позиций влево, при этом m элементов из конца массива перемещается в
начало. Массив состоит из n элементов.
Циклический сдвиг
будем организовывать с
помощью вспомогательного
массива P. “Хвост массива
пересылается во
вспомогательный массив, все
остальные элементы
перемещаются влево на m
по
зиций. Далее, в первые
элементы массива A
пересылаются элементы
вспомогательного массива, в
котором временно хранится
хвост исходного массива.
Такой вариант сдвига требует
больше памяти для
вспомогательного массива.
Программа 3
Var n, m, i: byte;
A: array[1 . . 50] of real;
P: array[1 . . 10] of real;
begin write('Ввод m 10, n');
readln(m,n);
writeln('Ввод ',n,'элементов');
For i:=1 to n do read(A[ i ]);
For i:=1 to m do P[ i ]:=A[ i ];
For i:=m+1 to n do A[i–m]:=A[ i ];
For i:=n–m+1 to n do
A[ i ]:=P[I–n+m];
writeln;
writeln('преобразованный
массив');
For i:=1 to n do write(A[ i ]:8:3);
writeln End.
Рисунок 5. Блок-схема
программы 3
Пример 2 Циклический сдвиг элементов массива влево                                Пример 3 Циклический сдвиг элементов массива влево

      Организовать циклический сдвиг элементов массива A на m                           Организовать циклический сдвиг элементов массива A на m
позиций влево, при этом m элементов из конца массива перемещается в               позиций влево, при этом m элементов из конца массива перемещается в
начало. Массив состоит из n элементов.                                            начало. Массив состоит из n элементов.
                                                                                              НАЧАЛО
      Циклический сдвиг будем организовывать с помощью                                                                                       Циклический       сдвиг
вспомогательной переменной P. Во вспомогательную переменную каждый                                                                     будем    организовывать     с
                                                                                               Печать
раз пересылается последний элемент массива A, затем все элементы                              Ввод n,m,                                помощью вспомогательного
                                      сдвигаются влево на одну                                  A[ i ]                                 массива P. “Хвост” массива
      НАЧАЛО
                                      позицию (в обратном порядке) и                                            Ввод массива           пересылается               во
       Печать                         на место первого элемента                                                                        вспомогательный массив, все
                                                                                                i:=1..n
      Ввод n,m                        помещается         содержимое                                                                    остальные           элементы
                                      вспомогательной переменной.                                                                      перемещаются влево на m
                                      Эта процедура повторяется m                               Печать
                                                                                                                                       позиций. Далее, в первые
       i:=1..n                                                                               Ввод A[ i ]
                                      раз. Такой вариант сдвига                                                  Запись первых m       элементы      массива       A
                                      требует больших затрат времени                                             элементов в P[ i ]    пересылаются        элементы
       Печать
     Ввод A[ i ]
                                      на многократное перемещение                                                                      вспомогательного массива, в
                                      элементов массива.                                       i:=1..m                                 котором временно хранится
                                                                                                                                       “хвост” исходного массива.
                                      Программа 2
                        Печать                                                                                                         Такой вариант сдвига требует
       i:=1..m                                                                               P[ i ]:=A[ i ]
                        Массив                                                                                      Сдвиг всех         больше       памяти       для
                                      Var      n, m, i, k: byte;                                                    элементов на m
                                                                                                                    позиций влево,
                                                                                                                                       вспомогательного массива.
                                            A: array[1 . . 50] of real;                                             начиная с m+1
       P:=A[ 1 ]         i:=1..n                                                                                                       Программа 3
                                            P: real;                                          i:=m+1..n
                                                                                                                                       Var    n, m, i: byte;
        k:=2..n          Экран        begin write('Ввод n, m');                                                                              A: array[1 . . 50] of real;
                         A[ i ]                                                             A[i–m]:=A[ i]        Перепись массива P
                                      readln(n,m);                                                               в “хвост” массива A         P: array[1 . . 10] of real;
      A[k–1]:=A[k]                    writeln('Ввод      ',n,'элементов');                                                             begin write('Ввод m ≤ 10, n');
                        КОНЕЦ
                                            for i:=1 to n do read(A[ i ]);                                            Печать           readln(m,n);
                                                                                              i:=n–m+1..n             Массив           writeln('Ввод ',n,'элементов');
       A[ n ]:=P                                for i:=1 to m do begin
                                                                                                                                         For i:=1 to n do read(A[ i ]);
                                                P:=A[ 1 ];                                A[ i ]:= P[ i –n+m]         i:=1..n            For i:=1 to m do P[ i ]:=A[ i ];
                                                    For k:=2 to n do                                                                   For i:=m+1 to n do A[i–m]:=A[ i ];
Рисунок 4. Подробный Блок-схема                                                                                      Печать                  For i:=n–m+1 to n do
                                                 A[k–1]:=A[ k ];
программы №2                                                                                                          A[ i ]
                                                                                       Печать массива A                                      A[ i ]:=P[I–n+m];
                                         A[ n ]:=P           end;
                                                                                                                                       writeln;
                                     writeln;    writeln('преобразованный                                            КОНЕЦ                    writeln('преобразованный
                                   массив');                                                                                           массив');
                                                                                          Рисунок 5. Блок-схема
                                       for i:=1 to n do write(A[ i ]:8:3);                                                             For i:=1 to n do write(A[ i ]:8:3);
                                                                                          программы №3
                                     writeln         End.                                                                                writeln         End.


                                                                             11   12