Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Национальный аэрокосмический университет «ХАИ»

Направление "Компьютерные науки"

Дисциплина "Обработка структур данных"

МЕТОДИЧЕСКОЕ ПОСОБИЕ

для 1-го курса

ОБРАБОТКА СТРУКТУР ДАННЫХ

Разработала

ст. преподаватель каф.

Троценко Надежда Васильевна

2013

ОГЛАВЛЕНИЕ

1. ПОНЯТИЕ СТРУКТУРНОГО ТИПА ДАННЫХ

2. МАССИВЫ

2.1. Теоретические сведения.

2.2 Задачи

3. СТРОКИ

3.1. Теоретические сведения.

3.2. Задачи

4. МНОЖЕСТВА

4.1. Теоретические сведения.

4.2. Задачи.

5. ФАЙЛЫ

5.1. Текстовые файлы

5.1.1.Теоретические сведения:

Определение текстового файла.

Структура текстового файла.

Обработка текстовых файлов.

Запись в файл.

Чтение из файла.

Стандартные процед

уры и функции

5.1.2.Задачи:

5.2. Типизированные

5.2.1. Теоретические сведения

Основные правила работы с типизированными файлами:

Стандартные процедуры и функции.

5.2.2. Задачи.

5.3 Нетипизированные

5.3.1 Теоретические сведения.

5.3.2 Задачи.

6. ЗАПИСИ

6.1. Теоретические сведения

Описание записи.

Работа с записями целиком.

Работа с полями записи.

Работа со списком записей.

6.2. Задачи.

1. ПОНЯТИЕ СТРУКТУРНОГО ТИПА ДАННЫХ

В курсе «Основы программирования и алгоритмические языки» вы изучали простые типы данных, характерным признаком которых является то, что они не содержат, как составляющие элементы, данные других типов. К таким типам относятся:

ѕ Byte (0..255);

ѕ Integer (-32768..32767);

ѕ Word (0..65535); одно число

ѕ Longint (-2147483648..2147483647); Shortint(-128…127)

ѕ Real (-2.9*10.. 1.7*10³⁸);

ѕ Char (#0..#255); - только один символ

ѕ Boolean (True, False) - одно логическое значение.

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

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

В языке Pascal используются

такие структурные типы:

ѕ массивы;

ѕ строки;

ѕ множества;

ѕ файлы.

ѕ записи.

Структурный тип массив может быть:

1). Type

T_mas = array[1..20] of Real; - каждый компонент - число, которое относится к простым типам данных.

2). Type

T_mas = array[1..20] of String[80]; - каждый компонент - структурный тип строка, состоящая из компонентов символ, которые относятся к простому типу данных .

Принадлежность компонента к структурированному типу позволяет говорить о вложенности типов.

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

Например, массив ежедневных температур воздуха на протяжении:

1). Месяца (одномерный массив);

Type

T_mas = array[1..31] of Real;

Var

Temperature:T_Mas;

структурный тип нетипизированные текстовый

Temperature	-5	-2	-3		-13	-12	-14	-20
	[1]	[2]	[3]	…	[28]	[29]	[30]	[31]

2). Года (двумерный массив).

Type

T_mas = array[1..12,1..31] of Real;

Var

Temperature:T_Mas;

Дни

Temperature

[1,1]	[1,2]	[1,3]	…	[1,28]	[1,29]	[1,30]	[1,31]
[2,1]	[2,2]	[2,3]	…	[2,28]	[2,29]	[2,30]	[2,31]
[3,1]	[3,2]	[3,3]	…	[3,28]	[3,29]	[3,30]	[3,31]
…	…	…	…	…	…	…	…
[12,1]	[12,2]	[12,3]	…	[12,28]	[12,29]	[12,30]	[12,31]

Структурный тип строка (тип String) можно рассматривать как одномерный массив символьного типа:

1). Type

Type_str =String[80];

Var - каждый компонент - символ,

Str: Type_str; который относится к простому

типу данных.

2). Type

Type_str = array[1..80] of Char;

Var

Str: Type_str;

Структурный тип множества - это тоже набор однородных элементов:

ѕ в числовое множество могут входить числа;

ѕ в символьное - любые символы;

ѕ в множество «Зверюшки» - кошка, мышка, зайка.

Но, если:

ѕ в массиве элементы могут принимать одно и то же значение (несколько дней подряд держится одинаковая температура);

ѕ то в множестве - любой элемент может присутствовать один раз.

Для хранения 1-го элемента множества в памяти компьютера нужен 1 бит. 1байт памяти хранит 8 элементов множества в отличие от массива, где каждый элемент занимает память в зависимости от типа.

Максимальное кол-во элементов множества -256. Максимальный объем памяти 32 байта.

Структурный тип файл позволяет решить проблему работы с большой информацией. Данные, которыми оперирует программа, работая с файлами:

ѕ сохраняются на диске;

ѕ остаются доступными как после завершения программы, так и после перезагрузки компьютера.

Три типа файлов в Pascal(е) позволяют выполнять всевозможные действия:

ѕ создавать файлы;

ѕ читать из файлов;

ѕ копировать;

ѕ редактировать.

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

Возникновение записей обусловлено потребностью объединения совокупности единиц беспорядочной информации в единую логическую структуру.

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

Здесь и:

ѕ номер по порядку в списке группы (Byte);

ѕ фамилия, имя, отчество (String);

ѕ адрес:

ѕ домашний адрес (String);

ѕ проживания по месту учебы (String);

ѕ день рождения (Word);

ѕ результаты сессии: (Byte);

ѕ математика;

ѕ физика;

ѕ программирование; и т.д.,

Схематически структуру такой записи можно изобразить следующим образом:

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Т.к. на факультете студенты разделяются на курсы, а на каждом курсе по несколько групп, то можно организовать двумерный массив записей, где:

ѕ строки массива - курс (1-ый, 2-ой, …);

ѕ столбцы - группы на курсе (110, 111, …,116);

ѕ элемент массива - запись с информацией на студента.



110 111 … 116

…

140 141 … 146

Группы (1*0…1*6)

2. МАССИВЫ

2.1 Теоретические сведения

2.1.1 Одномерный массив - это последовательность однотипных элементов. Проанализировав это определение, можно сделать вывод, что массив объединяет в себе 2 структуры:

ѕ множество элементов;

ѕ заданный на этом множестве порядок.

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

Порядок тоже определяется набором значений одного и того же типа, который называется индексным, а сами значения - индексами.

Индексный тип должен быть простым перечислимым типом данных.

Количество элементов называется размерностью или длиной.

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

ѕ размерность;

ѕ базовый тип;

ѕ индексный тип.

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

Описание массива выглядит следующим образом:

Type

<имя типа масс.>=Array[< нижн. индекс>,< верхн. индекс>] Of <тип элементов>;

Размерность массива = ORD (<верхний индекс> )- ORD (<нижний индекс>)+1;

Суммарный объем памяти, которая выделяется для хранения всех объявлений в разделе описания переменных VAR не больше 64 Кб. Поэтому существует ограничение на максимальное количество элементов массива:

ѕ Integer (не больше 32767) потому, что: 32767 х 2(б) = 65534;

ѕ Real (не больше10922) потому, что: 10922 х 6(б) = 65532.

Базовые операции обработки одномерных массивов:

ѕ инициализация массива;

ѕ вывод массива;

ѕ копирования массива;

ѕ поиск максимального и минимального элементов;

ѕ вычисление обобщенных характеристик (сумм элементов, их произведение);

ѕ поиск заданного элемента;

ѕ перестановка элементов или обмен между элементами массива;

ѕ вставка и удаление элемента.

Любая обработка массивов производится путем выполнения операций над его элементами.

Существует 2 самые простые операции над элементами одномерного массива:

ѕ выбор определенного элемента;

ѕ изменение его значения.

Для доступа к отдельному элементу применяется операция индексирования [], при помощи которой образуется выражение <имя массива>[<индексное выражение>]. Почему «выражение»? Потому что на месте индекса кроме А[1], А[2], …, может стоять А[I+1].

2.1.2 Многомерный массив

Одномерные массивы, как мы видим, применяются для хранения последовательностей. Но, для многих структур данных изображение в виде последовательности является неприемлемым. Например:

ѕ результат матчей футбольного чемпионата удобнее всего подать в виде квадратной таблицы;

ѕ наличие билетов на киносеанс на все места зала.

Для хранения таких структур применяются многомерные массивы, среди которых наиболее известные двумерные массивы (матрицы).

Описание массива выглядит следующим образом:

Type

<имя типа масс.>=Array[<нижний индекс строки>..<верхний индекс строки>, <нижний индекс столбца>..<верхний индекс столбца>,]

Of <тип элементов>;

Размерность массива =( ORD (<верхний индекс строки> ) - ORD (<нижний индекс строки>)+1) * ( ORD (<верхний индекс столбца>) - ORD (<нижний индекс столбца>)+1).

Базовые операции обработки двумерных массивов:

ѕ ввод и вывод матриц;

ѕ образование новой матрицы по заданному алгоритму;

ѕ поиск элементов матрицы по определенным критериям;

ѕ определение, удовлетворяет ли матрица или отдельные ее элементы определенному свойству;

ѕ выполнение определенных операций над компонентами матрицы (перестановки строк и столбцов, умножение, нахождение определителя).

Основные свойства массивов:

ѕ однородность (все элементы одного типа);

ѕ постоянство (размерность задается во время его оглашения и не изменяется во время работы с ним);

ѕ равнодоступность (способ доступа ко всем элемента одинакова - по индексу);

ѕ последовательность расположения (все элементы расположены в последовательных ячейках памяти);

ѕ индексирование (элементы идентифицируются своими индексами);

ѕ упорядоченность индексов (тип индексов простой перечислимый).

2.2 Задачи

Задача №1. Организовать ввод элементов одномерного массива.

Способ первый - в столбец.

Алгоритм решения:

1). Используя алгоритмическую конструкцию последовательности:

- вывести запрос на ввод количества элементов массива;

- ввести количество элементов массива.

2). Используя алгоритмическую конструкцию повторения:

ѕ вывести запрос на ввод элемента массива;

ѕ организовать ввод элемента массива.

Тогда на экране друг за другом будут появляться запросы на ввод и рядом курсор в ожидании ввода числа:

a[ 1]= _

a[ 2]= _ и т. д.

Справка.

1) Нужно помнить, что для ввода, вывода и обработки одномерного массива обязательно нужен цикл. Можно использовать явный цикл (For), т.к. размер массива известен.

2) Если размер массива N, то цикл будет иметь вид:

For i:=1 To n Do

Begin

...

End;

Что бы организовать ввод числа рядом с запросом ( А[ 1]= 12 ), нужно

|______|____|

Запрос число

использовать:

- для вывода запроса Write( ) (курсор останется на строке запроса);

- для ввода числа Readln( ) (курсор перейдет на следующую строку экрана).

Uses Crt;

Const K=20;

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массивы типа Mas (из K элементов).}

i:Byte; {I - параметр цикла.}

n:Byte; {N - кол-во обрабатываемых элементов из К.}

x,y:Byte; {X,Y - координаты установки курсора.}

BEGIN

ClrScr;

Write('Введите кол-во элементов массива>'); {Выводим запрос на ввод.}

Readln(n); {Вводим кол-во элементов массива.}

For i:=1 To n Do {Организовываем цикл для ввода элементов массива.}

Begin {Начало цикла ввода.}

Write('a[',i:2,']='); {Выводим запрос на ввод I-го эл.}

Readln(a[i]); {Вводим I-ый эл. массива.}

End; {Конец цикла ввода.}

Readkey; {Задержка вывода на экране.}

END.

Способ второй - в строку.

Алгоритм решения:

1). Используя алгоритмическую конструкцию последовательности задать начальные координаты Х и Y - позицию первого вывода на экран.

2). Используя алгоритмическую конструкцию повторения организовать ввод элементов массива, в котором:

ѕ каждый раз переустанавливать курсор на экране, двигаясь тем самым по строке экрана;

ѕ выводить запрос на ввод;

ѕ вводить значение элемента массива.

3). Используя конструкцию альтернативного ветвления контролировать выход за правую границу экрана, проверяя, на каждом шаге цикла, координату Х, т.к. ширина экрана в текстовом режиме равна 80 позициям. Если координата выходит за пределы экрана:

ѕ нужно увеличить координату Y для перехода на другую строку;

ѕ координату Х опять установить в начальную позицию строки.

Справка.

Для установки курсора на экране используйте процедуру GoToXY(x,y).

Uses Crt;

Const K=20;

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массивы типа Mas (из K элементов).}

i:Byte; {I - параметр цикла.}

n:Byte; {N - кол-во обрабатываемых элементов из К.}

x,y:Byte; {X,Y - координаты установки курсора.}

BEGIN

ClrScr;

Write('Введите кол-во элементов массива>');{Выводим запрос на ввод.}

Readln(n); {Вводим кол-во элементов массива.}

x:=1;y:=3; {Задаем координаты для ввода первого элемента.}

For i:=1 To n Do {Организовываем цикл для ввода элементов массива.}

Begin {Начало цикла ввода.}

GoToXY(x,y); {Устанавливаем курсор для ввода.}

Write('a[',i:2,']='); {Выводим запрос на ввод I-го эл.}

Readln(a[i]); {Вводим I-ый элемент массива.}

x:=x+15; {Увеличиваем координату ввода следующего эл. массива}

If x>75 Then {Проверяем координату Х на предмет выхода за}

Begin {границы экрана.}

x:=1; {Устанавливаем координату Х в первую позицию}

{экрана (начало ввода следующей строки).}

inc(y); End; {Переводим курсор на другую строку.}

End; {Конец цикла ввода.}

Readkey; {Задержка вывода на экране.}

END.

Задача №2. Организовать ввод элементов двухмерного массива по строкам следующим образом:

А[1,1]=12.3 A[1,2]=5.6 A[1,3]=32.4

A[2.1]= 0.8 и т.д.

Для организации такого ввода по строкам необходимо переустанавливать курсор по Х (по строке), а при переходе на ввод новую строку, Х опять устанавливатьв исходную позицию (начальную координату).

Алгоритм решения:

1). Используя алгоритмическую конструкцию последовательност ввести размер массива (кол-во строк и кол-во столбцов).

2). Используя алгоритмических конструкций повторения по строкам:

ѕ задавать начальную координату Х;

ѕ используя алгоритмических конструкций повторения по элементам строки (столбцам);

- устанавливать курсор,

- выводить запрос на ввод,

- вводить очередной элемент строки массива ;

Справка

1). Описание двумерного массива отличается от одномерного массива, что он состоит из нескольких строк и нескольких столбцов:

Var

A:array[1..n,1..m] of Real; {n - количество строк, m - количество столбцов.}

2). Для ввода, вывода и обработки двухмерного массива обязательно нужно организовать 2 цикла:

For I:=1 To n Do { по строкам }

For J:=1 To m Do { по столбцам }

3). Внутренний цикл "крутится" быстрее, т.е. при I=1, J измениться от 1 до M.

4). Для установки курсора использовать процедуру GoToXY(x,y),

где x,y - кооринаты экрана (X изменяется от 1 до 80, Y - от 1 до 25).

Uses Crt;

Const

K=20; k1=20; {K - количество строк;}

{K1 - количество столбцов.}

Type

Mas=Array[1..k,1..k1] of Real;{Mas - тип массива из (K на K1) элементов.}

Var

A:Mas; {А - массив типа Mas.}

i,j:Byte; {I,J - параметры циклов.}

n,m:Byte; {N - кол-во строк массива, M - кол-во столбцов.}

x:Byte; {X - координата экрана (от 1 до 80).}

BEGIN

ClrScr;

Write('Введите размер массива>'); {Выводим запрос на ввод размера массива.}

Readln(n,m); {Вводим кол-во строк и кол-во столбцов массива.}

For i:=1 To n Do {Организовываем цикл по строкам массива.}

Begin Начало цикла по строкам.}

x:=2; {Задаем начальную позицию курсора по Х каждой новой строки массива}

For j:=1 To m Do {Организовываем цикл по столбцам.}

Begin {Начало цикла по столбцам.}

GoToXY(x,i+1); {Устанавливаем курсор в позицию вывода запроса}

Write('A[',i:2,j:2,']='); {и ввода каждого элемента массива.}

Readln(a[i,j]); {Вводим [I,J]-ый элемент массива.}

x:=x+15; {Изменяем координату установки курсора по Х }

End; {Конец цикла по столбцам.}

Writeln; {Переходим на новую строку экрана.}

End; {Конец цикла по строкам.}

Readkey;

END.

Задача №3. Определить сумму элементов массива вещественного типа.

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

Алгоритм решения:

ѕ сформируем массив;

ѕ обнулим сумму перед алгоритмической конструкцией повтореня, в которой будем накапливать сумму элементов массива вещественного типа;

ѕ выведем результат.

Uses Crt;

Const K=20;

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массив типа Mas (из K элементов).}

i:Byte; {I - параметр цикла.}

n:Byte; {N - кол-во обрабатываемых элементов из К.}

S:Real; {S - сумма элементов массива.}

BEGIN

ClrScr; {Чистим экран.}

{1 часть - формирование одномерного массива.}

Write('Введите кол-во элементов массива');{Выводим запрос на ввод.}

Readln(n); {Вводим кол-ва элементов.}

For i:=1 To n Do {Организовываем цикл для ввода элементов массива.}

Begin {Начало цикла.}

Write('a[',i:2,']='); {Выводим запроса на ввод I-го эл.}

Readln(a[i]); {Вводим I-ый эл. массива.}

End; {Конец цикла.}

{2 часть - нахождение суммы элементов массива.}

s:=0; {Обнуляем сумму.}

For i:=1 To n Do {Организовываем цикл по элементам массива.}

s:=s+a[i]; {Накапливаем сумму элементов.}

{3 часть - вывод результата.}

Write('Сумма элементов массива - ',s:7:2);{Выводим результат.}

Readkey; {Задержка результата не экране.}

END.

Задача №4. В одномерном массиве вещественных чисел определить сумму отрицательных и сумму положительных элементов массива.

Алгоритм решения.

Задачу условно разбиваем на 3 части:

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

2). Обработка массива - нахождение суммы положительных элементов и суммы отрицательных элементов массива. Для нахождения сумм:

ѕ обнуляем суммы до алгоритмической конструкции повторения (цикла), в которой, используя конструкцию альтернативного ветвления, если:

- элемент массива положительный, накапливаем одну сумму;

- если элемент массива отрицательный, накапливаем другую сумму.

3). Вывод результата.

Uses Crt;

Const K=20;

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массивы типа Mas (из K элементов).}

i:Byte; {I -параметр цикла.}

n:Byte; {N - кол-во обрабатываемых элементов из 20.}

s1,s2:Real; {S1 и S2-суммы положительных и отрицательных эл. массива}

BEGIN

ClrScr; {Чистим экран.}

{1 - Ввод исходных данных.}

Write('Введите кол-во элементов массива>');{Выводим запрос на ввод.}

Readln(n); {Вводим кол-ва элементов.}

For i:=1 To n Do {Организовываем цикл для ввода элементов массива.}

Begin {Начало цикла ввода.}

Write('a[',i:2,']='); {Выводим запрос на ввод I-го элемента.}

Readln(a[i]); {Вводим I-ый элемент массива.}

End; {Конец цикла ввода.}

{2 - нахождение суммы положительных эл. и суммы отриц. эл. массива.}

s1:=0; {Обнуляем счетчики сумм для положительных}

s2:=0; {и отрицательных элементов масива.}

For i:=1 To n Do {Организовываем цикл по элементам массива.}

If a[i]>0 {Если элемент - положительный,}

Then s1:=s1+a[i] {накапливаем одну сумму.}

Else s2:=s2+a[i]; { отрицательный - накапливаем в другую сумму.}}

{3 - Вывод результата.}

Writeln('Сумма положительных - ',s1:7:3); {Выводим сумму положительных.}

Writeln('Сумма отрицательных - ',s2:7:3); {Выводим сумму отрицательных.}

Readkey; {Задержка вывода на экране.}

END.

Задача №5. В двумерном массиве вещественных чисел определить строку с наибольшей суммой.

Ввод элементов массива организовать по строкам следующим образом:

А[1,1]=12.3 A[1,2]=5.6 A[1,3]=32.4

A[2.1]= и т.д.

Алгоритм решения:

- ввести размерность массива;

- организовать циклы для ввода элементов массива;

- задать "стартовый" максимум;

- организовать цикл по строкам, в котором:

ѕ обнулить сумму для строки;

ѕ организовать цикл (внутренний) по столбцам, в котором накопить сумму элементов строки;

ѕ сравнить с максимумом и, если сумма больше, то зафиксировать ее и строку, в которой найдена эта сумма;

- вывести результат на экран.

Справка:

1). Описание двумерного массива отличается от одномерного, т.к. он состоит из нескольких строк и нескольких столбцов.

Var

A:array[1..n,1..m] of Real;{ n - количество строк, m - количество столбцов.}

2). Для ввода, вывода и обработки двумерного массива обязательно нужно организовать 2 цикла: по строкам и по столбцам:

For I:=1 To n Do

For J:=1 To m Do …

3). Внутренний цикл "крутится" быстрее, т.е. при I=1, J измениться от 1 до M.

Uses Crt;

Const

K=20; k1=20; {K - количество строк;K1- количество столбцов.}

Type

Mas=Array[1..k,1..k1] of Real; {Mas- тип массива из K*К1 элементов.}

Var

A:Mas; {А - массив типа Mas (из K*K1 элементов)}

i,j:Byte; {I,J - параметры циклов.}

n,m:Byte; {N, M - кол-во вводимых строк и столбцов}

max:Real; {MAX - максимальная сумма строки.}

x,max_i:Byte; {X - позиция курсора;}

{MAX_I - строка с максимальной суммой.}

s:Real; {S - сумма элементов строки.}

BEGIN

ClrScr; {Чистим экран.}

Write('Введите размер массива ');{Выводим запрос на ввод.}

Readln(n,m); {Вводим кол-во строк и столбцов.}

ClrScr; {Чистим экран.}

For i:=1 To n Do {Цикл формирования массива по строкам.}

Begin {Начало цикла по строкам.}

x:=1; {Задаем позицию курсора по Х для ввода.}

For j:=1 To m Do {Цикл по столбцам.}

Begin {Начало цикла по столбцам.}

GoToXY(x,i); {Установка курсора при вводе элементов массива.}

Write('a[',i:2,',',j:2,']='); {Вывод запроса на ввод.}

Read(a[i,j]); {Ввод [I,J]-го эл. массива.}

x:=x+15; {Переустанавливаем курсор по Х.}

End; {Конец цикла по столбцам.}

End; {Конец цикла по строкам.}

max:=a[1,1]; {"Стартовый" максимум.}

For i:=1 To n Do {Цикл по строкам.}

Begin {Начало цикла по строкам.}

s:=0; {Сумму каждой новой строки задаем равной 0.}

For j:=1 TO m Do {Цикл по столбцам I-ой строки.}

s:=s+a[i,j]; {Находим сумму элементов строки.}

If s>max Then Begin {Если полученная сумма больше имеющейся,}

max_i:=i; {Запоминаем строку.}

max:=s; {Запоминаем полученную сумму как максимум.}

End; {Конец условия.}

End; {Конец цикла по строкам.}

Writeln;

Writeln(max_i,' строка - ',max:10:4);{Вывод результата.}

Readkey; {Задержка вывода.}

END.

Задача №6. Определить максимальный элемент в массиве вещественных чисел.

Алгоритм решения.

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

Для этого:

- ввести количество элементов массива ;

- сформировать массив;

- определиться со "стартовым" максимумом;

- в цикле по элементам массива сравнивать каждый элемент массива с

максимумом и, если элемент массива больше ранее заданного максимума, зафиксировать его.

Uses Crt;

Const K=20; {Количество элементов в массиве.}

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массив типа Mas (из K элементов).}

i:Byte; {I -параметр цикла.}

n:Byte; {N - кол-во обрабатываемых элементов массива.}

max:Real; {MAX - максимальный элемент.}

BEGIN

ClrScr; {Чистка экрана}

Write('Введите кол-во элементов массива>');{Выводим запрос на ввод.}

Readln(n); {Вводим кол-во элементов.}

For i:=1 To n Do {Цикл для ввода элементов массива.}

Begin {Начало цикла формирования массива.}

Write('a[',i:2,']='); {Выводим запроса на ввод I-го эл.}

Readln(a[i]); {Вводим I-ый эл. массива.}

End; {Конец цикла формирования массива.}

max:=a[1]; {В максимум заносим первый элемент массива.}

For i:=1 To n Do {Цикл по элементам массива.}

If a[i]>max Then max:=a[i]; {Если текущий элемент больше максимума,}

{то переприсваиваем.}

Writeln('максимальный элемент - ',max:10:4);{Выводим результат.}

Readkey; {Задержка результата на экране.}

END.

Задача №7. В массиве чисел вещественного типа определить максимальный элемент среди положительных и минимальный среди отрицательных.

Алгоритм решения.

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

Поэтому в "стартовый" максимум нужно задать положительное число из элементов массива, а в "стартовый" минимум - отрицательное число.

Поэтому:

- вводим количество элементов массива;

- в цикле формируем массив;

- определяемся со "стартовыми" максимумом и минимумом;

- в цикле по элементам массива:

ѕ положительные элементы сравниваем с максимумом,

ѕ отрицательные элементы сравниваем с минимумом;

- выводим максимум и минимум.

Uses Crt;

Const K=20; {Количество элементов в массиве}

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов}

Var

A:Mas; {А - массив типа Mas (из K элементов)}

i:Byte; {I -параметр цикла}

n:Byte; {N - кол-во обрабатываемых элементов из K}

min_o,max_p:real; {Min_O - искомый минимум}

{MAX_P - искомый максимум}

BEGIN

ClrScr;

{ Организация ввода кол-ва элементов массива}

Write('Введите кол-во элементов массива>');{Вывод запроса на ввод.}

Readln(n); {Ввод кол-ва элементов.}

{Формирование массива}

For i:=1 To n Do {Цикл для ввода элементов массива.}

Begin {Начало цикла формирования массива.}

Write('a[',i:2,']='); {Вывод запроса на ввод I-го эл.}

Readln(a[i]); {Ввод I-го эл. массива.}

End; {Конец цикла формирования массива.}

{Нахождение «стартовых» минимума и максимума}

For i:=1 To N Do {Цикл определения "стартовых" максимума и минимума.}

If a[i]>0 Then max_p:=a[i] {Положительный заносим в максимум.}

Else min_o:=a[i]; {Отрицательный заносим в минимум.}

{Нахождение «истинных» минимума и максимума}

For i:=1 To n Do {Цикл для определения истинного максимума и минимума}

Begin {Начало цикла}

If (a[i]>0) And (a[i]>max_p) {Если элемент положительный и больше}

Then max_p:=a[i]; {максимума, запоминаем в максимуме.}

If (a[i]<0) And (a[i]<min_o) {Если элемент отрицательный и меньше}

Then min_o:=a[i]; {минимума, запоминаем в минимуме.}

End; {Конец цикла определения истинных максимума и минимума.}

{Вывод результата}

Writeln('- ',max_p:10:4); {Вывод максимума.}

Writeln('- ',min_o:10:4); {Вывод минимума.}

Readkey; {Задержка результата}

END.

Задача №8. В массиве чисел вещественного типа определить максимальный элемент среди положительных и минимальный среди отрицательных. Организовать вывод всех элементов массива, выделив максимальный и минимальный элементы разными цветами.

Эта задача отличается от предыдущей только выводом, так как нужно вывести сами элементы массива и выделить разными цветами «уникальные» элементы.

Uses Crt;

Const K=20; {Количество элементов в массиве.}

Type

Mas=Array[1..k] of Real; {Mas- тип массива из K элементов.}

Var

A:Mas; {А - массив типа Mas (из K элементов).}

i:Byte; {I -параметр циклa.}

n:Byte; {N - кол-во обрабатываемых элементов из K.}

min_o,max_p:real; {Min_O и MAX_P - искомые минимум и максимум}

BEGIN

ClrScr;

{1}Write('Введите кол-во элементов массива');{Вывод запроса на ввод.}

Readln(n); {Ввод кол-ва элементов.}

{2} For i:=1 To n Do {Цикл для ввода элементов массива.}

Begin {Начало цикла формирования массива.}

Write('a[',i:2,']='); {Вывод запроса на ввод I-го эл.}

Readln(a[i]); {Ввод I-го эл. массива.}

End; {Конец цикла формирования массива.}

{3} For i:=1 To N Do {Цикл определения "стартовых" максимума и минимума.}

If a[i]>0 Then max_p:=a[i] {Положительный заносим в максимум.}

Else min_o:=a[i]; {Отрицательный заносим в минимум.}

{4} For i:=1 To n Do {Цикл для определения истинного максимума и минимума.}

Begin

If (a[i]>0) And (a[i]>max_p) {Если элемент положительный и больше}

Then max_p:=a[i]; {максимума, запоминаем в максимуме.}

If (a[i]<0) And (a[i]<min_o) {Если элемент отрицательный и меньше}

Then min_o:=a[i]; {минимума, запоминаем в минимуме.}

End; {Конец цикла определения «истинных» максимума и минимума}

{5 вывод} ClrScr; {Чистим экран перед выводом результата.}

For i:=1 to n Do {Цикл для вывода.}

Begin {Начало цикла.}

TextColor(7); {Цвет для всех.}

If (a[i]=max_p) Then Textcolor(4) {Цвет для MAX.}

If (a[i]=min_o) Then TextColor(5) {Цвет для MIN.}

Write('a[',i:2,']=',a[i]:8:5,' ');{Вывод элементов массива.}

End; {Конец цикла вывода.}

Readkey; {Задержка результата}

END.

Задача №9. Сгенерировать двумерный массив, определить максимальный элемент и вывести на экран в матричном виде (по строкам), выделив максимальный элемент уникальным цветом. Использовать процедуры.

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

1) Организовать инициализацию массива А(5 х 5) по строкам путем генерации случайных чисел.

2) Определить максимальный элемент массива и обязательно запомнить месторасположения, зафиксировав индексы, этого элемента. Для этого:

ѕ в Max занести значение первого элемента массива;

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

3) При выводе элементов массива по строкам сравнивать текущие индексы массива с теми, что запомнили и, при совпадении выводить уникальным цветом.

Uses Crt;

Type

Mas=Array[1..5,1..5] of Integer;

Var

A: Mas {массив из 25 элементов}

Max:Integer; {для максимума}

imax, jmax: byte; {для индексов расположения максимума}

{---------------Процедура формирования массива---------------------------}

Procedure Input_mas (Var A:mas);

Var

I, j:Byte; {индексы текущих элементов массива}

Begin

{Инициализация массива по строкам}

Randomize;

For i:=1 to 5 do

For j:=1 to 5 do

A[I,j]:=Random(20); {генерируем}

End;{------------------------------------------------------------------------------------}

{------------Процедура нахождение максимального значения массива---------}

Procedure Max_mas (A:mas; Var max, imax, jmax: Integer);

{макс. значение массива и его индексы}

Var

I, j:Byte; { индексы текущих элементов массива}

Begin

Max:=A[1,1]; {задаем начальный максимум массива}

For i:=1 to 5 do

For j:=1 to 5 do

If max<A[I,j] Then Begin Max:=A[I,j]; {фиксируем, как максимальное}

imax:=I; jmax:=j; {фиксируем индексы }

End;

End;{------------------------------------------------------------------------------------}

{---------------Процедура вывода массива-------------------------------------}

Procedure Write_mas(A:mas; imax, jmax: Integer);

Var

I, j:Byte; {индексы текущих элементов массива}

Begin

For i:=1 to 5 do {вывод элементов массива по строкам}

Begin

For j:=1 to 5 do

Begin

If (i=imax) and(j=jmax) Then Textcolor(5) {цвет максимального}

Else TextColor(7); {цвет всех остальных}

Write(` `,A[I,j]:6); {вывод по формату }

End;

Writeln; {переход на другую строку}

End;

End;{------------------------------------------------------------------------------------}

BEGIN{-------------ГЛАВНАЯ ПРОГРАММА-------------------------------}

ClrScr;

Input_mas(A);

Max_mas(A, max, imax, jmax);

Write_mas(A, imax, jmax);

Readkey;

END.

Задача №10. Сформировать массив, используя генерацию случайных чисел. Отсортировать массив по возрастанию и вывести на экран, расположив результат в два столбика, предусмотрев постраничный просмотр результата.

Исходный массив Массив после сортировки

8 -6

-5 -5

3 3

6 6

-6 8

Способ «Один со всеми» заключается в том, что последовательно берутся элементы массива и сравниваются со всеми остальными элементами (первый - со всеми, затем второй - со всеми и т.д.)

(следующий) элемент и опять сравнивается со всеми остальными и т.д. Если этот элемент окажется меньше какого-либо из всех остальных, используя метод «прямого обмена», меняем их местами.

Внешний цикл исх. 1 шаг 2 шаг 3 шаг 4 шаг рез.

8| -5 -5 -5 -6 |-6

-5| 8 8 8 8 3 6 -5 |-5

3| 3 3 3 3 8 8 8 3 3 | 3

6| 6 6 6 6 6 3 3 8 8 6 | 6

-6| -6 -6 -6 -5 -5 -5 6 6 6 8 | 8

Внутренний ц. 1ш. 2ш. 3ш. 4ш. 1ш. 2ш. 3ш. 1ш. 2ш. 1ш.

|________________| |___________| |_____| |_|

4 шага 3 шага 2 шага 1 шаг

Из примера видно, что:

- внешний цикл начинается с 1 и "крутится" на единицу меньше, чем кол-во элементов массива;

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

Справка:

1). Функция RANDOM() имеет один параметр, который указывает предельную границу диапазона, из которого будут выбираться числа. Например, если написать RANDOM(50), то в массив могут быть занесены 0..49. Обратите внимание, что числа 50 среди них не будет.

2). Что бы при каждом запуске программы в массив заносились разные числа, нужно использовать процедуру RANDOMIZE.

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

4). За один цикл сортировку выполнить не реально. Поэтому необходимо построить еще один внешний цикл

5). После того, как внутренний цикл закончит работу, вверх "поднимется" самый маленький элемент. Поэтому, начиная сравнивать следующий элемент со всеми остальными, внутренний цикл необходимо ограничить,т.к. количество сравниваемых пар постоянно будет уменьшаться;

6. Для одновременного вывода исходного и результирующего нужно предусмотреть еще один массив для хранения исходных значений.

Uses Crt;

Const K=20;

Type

Mas=Array[1..k] Of Integer; {Mas- тип массива из K элементов.}

Var

A,B:Mas; {А,B - массивы типа Mas (из K элементов).}

i,j:Byte; {I,J -параметры циклов.}

n:Byte; {N - кол-во обрабатываемых элементов из K.}

y:Byte; {Y - позиция курсора на экране.}

buf:Integer; {BUF - для временного хранения элемента.}

BEGIN

ClrScr;

Write('Введите кол-во элементов массива>');{Выводим запрос на ввод.}

Readln(n); {Вводим кол-во элементов.}

{Формируем массив}

Randomize; {Процедура генерации разных чисел.}

for i:=1 To n Do {Цикл формирования элементов массива }

Begin

a[i]:=Random(65535)-32767; {Генерируем случайные числа из}

{диапазона -32768..32767.}

Write('a[',i:2,']=',a[i]:8,' '); {Организовываем контрольный вывод}

End; {I-го эл. на экран по формату}

{Сортируем}

B:=A; {Сохраняем массив в дополнительной переменной.}

For j:=1 To n-1 Do {Внешний цикл сортировки }

For i:=1+j To n Do {Внутренний цикл зависит от j, т. к. начинаем}

{со следующего элемента.}

If a[j]>a[i] Then Begin {Сравниваем два рядом стоящих эл. массива.}

buf:=a[j]; {Сохраняем J-ый эл. в буфер.}

a[j]:=a[i]; {Вместо J-го эл. записываем I-ый эл.}

a[i]:=buf; {Возвравщаем I-му эл. значение из буфера.}

End;

{Выводим результат}

ClrScr; {Чистим экран перед выводом.}

GoToXY(10,2);Write('Исходный массив'); {Выводим}

GoToXY(35,2);Write('После сортировки'); {"шапку" вывода.}

y:=4; {Задаем позицию первого вывода.}

For i:=1 To n Do {Организовываем цикл для вывода.}

Begin

GoToXY(10,y); {Устанавливаем курсор для вывода}

Write('a[',i:2,']=',b[i]:8,' '); {исходного эл. массива и выводим.}

GoToXY(35,y); {Устанавливаем курсор для вывода}

Write('a[',i:2,']=',a[i]:8,' '); {результирующего эл. массива и выводим}

y:=y+1; {Увеличиваем Y для следующего вывода.}

If (y Mod 24)=0 Then Begin {Если остаток от деления =0,}

Readkey; {задерживаем выдачу на экране,}

y:=4; {устанавливаем курсор для первого вывода следующей страницы.}

End;

End;

{Чистим экран от вывода предыдущей страницы}

For i:=y To 25 Do {Организовываем цикл от позиции последнего}

Begin {вывода до конца страницы (25 строк).}

GoToXY(1,i); {Устанавливаем курсор и выводим}

Write(' ');{пустую строку.}

End;

Readkey;

END.

Задача №11. Сформировать массив, используя генерацию случайных чисел. Отсортировать массив по возрастанию без дополнительного буфера при перестановке элементов и вывести на экран, расположив результат в два столбика, предусмотрев постраничный просмотр результата.

Исходный массив Массив после сортировки

8 -6

-5 -5

3 3

6 6

-6 8

Этот способ заключается в том, что саму сортировку будем производить методом «пузырька», т.е. сравнивать 2-а рядом стоящие элементы (I- ый будем сравнивать с (I+1)-ым - попарное сравнение рядом стоящих), но менять местами элементы массива будем без дополнительного буфера.

Внешний цикл исх. 1 шаг 2 шаг 3 шаг 4 шаг рез.

8| -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 | -6

-5| 8 3 3 3 3 3 3 3 -6 -6 | -5

3| 3 8 6 6 6 6 -6 -6 3 | 3

6| 6 6 8 -6 -6 -6 6 | 6

-6| -6 -6 -6 8 | 8

Внутренний ц. 1ш. 2ш. 3ш. 4ш. 1ш. 2ш. 3ш. 1ш. 2ш. 1ш.

|________________| |_______________| |_______| |__|

4 шага 3 шага 2 шага 1 шаг

Из примера видно, что:

- внешний цикл "крутится" на единицу меньше, чем кол-во элементов массива;

- внутренний цикл всегда начинается с 1-го и, каждый раз, кол-во «прокруток» уменьшается.

Для решения нужно:

- сформировать массив, используя функцию генерации RANDOM;

- попарно сравнивая два рядом стоящие элементы массива, менять их местами;

если предыдущий окажется больше последующуго, менять местами;

- вывести результат на экран.

Справка:

1). Функция RANDOM() имеет один параметр, который указывает предельную границу диапазона, из которого будут выбираться числа. Например, если написать RANDOM(50), то в массив могут быть занесены 0..49. Обратите внимание, что числа 50 среди них не будет.

2). Что бы при каждом запуске программы в массив заносились разные числа, нужно использовать процедуру RANDOMIZE.

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

- в предыдущий сумму рядом стоящих элементов

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

a[1]:= 8 + (-5); (a[1]= 3) - с нашего примера

- в последующий запомнить результат вычитания из предыдущего последующего a[i+1]:=a[i]-a[i+1];

a[ 2]:= 3 - (-5); ( a[ 2]= 8)

- в предыдущий - результат вычитания из предыдущего последующего

a[i]:=a[i]-a[i+1];

a[1]:= 3 - 8; (a[1]= -5)

4).За один цикл сортировку выполнить не реально. Поэтому необходимо построить еще один внешний цикл;

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

6).Для одновременного вывода исходного и результирующего нужно предусмотреть еще один массив для хранения исходных значений.

Uses Crt;

Const

K=20;

Type

Mas=Array[1..k] Of Integer; {Mas- тип массива из K элементов.}

Var

A,B:Mas; {А,B - массивы типа Mas (из K элементов).}

i,j:Byte; {I,J -параметры циклов}

n:Byte; {N - кол-во обрабатываемых элементов из K.}

y:Byte; {Y - позиция курсора на экране.}

...