- •Предисловие
- •Основы программирования
- •Понятие алгоритма.
- •Алгоритм Евклида.
- •Задача о поездах и мухе
- •Вместо лирического отступления
- •Этапы подготовки задачи для решения на компьютере
- •Примеры разработки алгоритмов
- •Решение квадратного уравнения.
- •Вычисление интегралов
- •Обработка результатов эксперимента
- •Решение системы линейных алгебраических уравнений
- •Введение в язык программирования Pascal
- •Основные элементы языка
- •Переменные. Стандартные типы.
- •Операции отношения
- •Раздел описаний переменных
- •Выражения. Порядок выполнения операций.
- •Константы
- •Комментарии в программе
- •Операторы
- •2.1.7.1. Оператор присваивания
- •2.1.7.2. Операторы ввода/вывода
- •2.1.7.3. Операторы инкремента и декремента
- •Среда разработки Lazarus
- •Русский язык в консольных приложениях
- •Первая программа
- •Открытие существующего проекта
- •Другие способы создания консольных приложений
- •Типовой пустой проект
- •Операции с целыми числами
- •Вместо лирического отступления 2
- •Стандартные функции с целыми аргументами
- •Операции с вещественными числами (тип real).
- •Форматирование вывода
- •Одновременное использование вещественных и целых чисел.
- •Другие стандартные функции с вещественными аргументами
- •Булевы переменные
- •Условные операторы.
- •2.1.22.1 Оператор if …. then
- •2.1.22.2. Оператор if …then ... else
- •Операторы цикла
- •2.1.23.1. Оператор цикла с предусловием
- •2.1.23.2. Оператор цикла с постусловием
- •2.1.23.3. Оператор цикла с параметром.
- •2.1.23.4. Второй вариант оператора цикла с параметром
- •Оператор выбора case
- •Организация простейшего контроля ввода данных.
- •Вычисление сумм сходящихся рядов
- •Реализация некоторых алгоритмов главы 1.
- •Программа решения задачи о поездах и мухе
- •Программа вычисления определенного интеграла
- •Более сложные элементы языка
- •Общая структура Паскаль – программы
- •Процедуры и функции
- •3.1.1.1 Структура процедуры
- •3.1.1.2. Структура функции
- •3.1.1.3 Глобальные и локальные переменные
- •3.1.1.4 Способы передачи параметров
- •3.1.1.5 Процедуры завершения
- •Еще раз о типах данных
- •Классификация типов данных
- •3.2.1.1 Целый тип
- •3.2.1.2. Интервальный тип
- •3.2.1.3. Перечислимый тип
- •3.2.1.4. Множества
- •3.2.1.5. Логический тип
- •3.2.1.6. Вещественный тип
- •3.2.1.7. Указатели
- •Обработка символьной информации в Паскале
- •Символьные и строковые типы данных.
- •3.3.1.1. Тип Char
- •3.3.1.2. Функции для работы с символами
- •3.3.1.3. Тип String
- •3.3.1.4. Строковые процедуры и функции
- •Массивы
- •Динамические массивы
- •Программа решения системы линейных алгебраических уравнений методом Гаусса
- •3.4.1.1. Вариант 1 – с goto
- •3.4.1.2. Вариант 2 – без goto
- •3.4.1.3. Вариант 3 – наилучшая реализация
- •Модули в Паскале
- •Структура модуля
- •Системные модули
- •3.5.2.1. Модуль CRT
- •Файлы
- •Тип данных – запись
- •Файловые типы
- •Процедуры для работы с файлами
- •3.6.3.1. Общие процедуры для работы с файлами всех типов
- •3.6.3.2. Процедуры для работы с текстовыми файлами
- •3.6.3.3. Процедуры для работы с типизированными файлами
- •3.6.3.4. Процедуры для работы с нетипизированными файлами
- •3.6.3.5. Организация контроля ввода/вывода при работе файлами
- •3.6.3.6. Создание простой базы данных с типизированными файлами.
- •Алгоритмы сортировки
- •Обменная сортировка (метод "пузырька")
- •Сортировка выбором
- •Сортировка вставками
- •Метод быстрой сортировки
- •Алгоритмы поиска
- •Поиск в массивах
- •Вставка и удаление элементов в упорядоченном массиве
- •Динамические структуры данных
- •Представление в памяти компьютера динамических структур.
- •Реализация стека с помощью массивов
- •Указатели
- •Стандартные операции с линейными списками
- •Реализация динамических структур линейными списками
- •4.3.6.1. Реализация стека
- •4.3.6.2. Реализация очереди с помощью линейного списка
- •4.3.6.3. Реализация двоичного дерева с помощью линейного списка
- •Сортировка и поиск с помощью двоичного дерева
- •Три источника и три составные части ООП.
- •Классы и объекты.
- •Обращение к членам класса.
- •Инкапсуляция
- •Спецификаторы доступа.
- •Свойства.
- •Наследование
- •Полиморфизм
- •Раннее связывание.
- •Позднее связывание.
- •Конструкторы и деструкторы.
- •Элементы графического интерфейса
- •Различия между консольными и графическими приложениями
- •Визуальное программирование в среде Lazarus
- •Создание графического приложения
- •Форма и ее основные свойства
- •Компоненты
- •Обработчики событий
- •Простейшие компоненты
- •6.3.5.1. Компонент TLabel
- •6.3.5.2. Кнопки TButton, TBitBtn и TSpeedButton
- •6.3.6.1. Компонент TEdit
- •6.3.6.2. Компонент TLabeledEdit
- •6.3.7.1. Компонент TMaskEdit
- •Специальные компоненты для ввода чисел
- •Тестирование и отладка программы
- •Компоненты отображения и выбора данных
- •6.3.10.1. Компонент TMemo
- •6.3.10.2. Компонент TStringGrid
- •6.3.10.3. Компоненты выбора
- •Компонент TListBox
- •Компонент TComboBox
- •Компоненты выбора – переключатели
- •6.3.10.4. Компоненты отображения структурированных данных
- •Компонент TTreeView
- •Компонент TListView
- •Организация меню. Механизм действий - Actions
- •6.3.11.1. Компонент TMainMenu
- •6.3.11.2. Компонент TToolBar
- •6.3.11.3. Компонент TActionList
- •6.3.11.4. Создание приложений с изменяемыми размерами окон
- •Послесловие
- •Литература
- •Алфавитный указатель
3.4 Массивы
____________________________________________________________________
goto L5; end;
x[i]:= (b[i] + S) / a[i, i]; if not(i = 1) then
begin
i:= i - 1; goto L4;
end;
for i:= 1 to n do
writeln('x', i, '= ', x[i]:0:4); writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;
end.
3.4.1.2. Вариант 2 – без goto
program Gauss_console_app; {$mode objfpc}{$H+}
uses
CRT, FileUtil; var
a:array[1..3, 1..3] of real;
b:array[1..3] of real;
x: array[1..3] of real; i, j, k, p, n: integer; m, S, t: real;
begin
{Ввод коэффициентов расширенной матрицы} n:= 3;
for i:=1 to n do begin
for j:=1 to n do begin
writeln(UTF8ToConsole('Введите a'), i, j); readln (a[i, j]);
end;
writeln(UTF8ToConsole('Введите b'), i); readln(b[i]);
end;
{Основная часть программы} k:= 1;
206
Глава 3 Более сложные элементы языка
____________________________________________________________________
while true do begin
i:= k + 1;
if (a[k, k] = 0) then begin
{перестановка уравнений}
p:= k; // в алгоритме используется буква l, но она похожа на 1 // Поэтому используем идентификатор p
while true do begin
if abs(a[i, k]) > abs(a[p, k]) then p:= i; if i = n then break;
i:= i + 1; continue;
end;
if p= k then i:= k + 1 else
begin j:= k;
while true do begin
t:= a[k, j];
a[k, j]:= a[p, j]; a[p, j]:= t;
if j = n then break; j:= j + 1; continue;
end;
t:= b[k]; b[k]:= b[p]; b[p]:= t;
end;
end; // конец блока перестановки уравнений while true do
begin
m:=a[i, k] / a[k, k]; a[i, k]:= 0;
j:= k + 1; while true do begin
a[i, j]:= a[i, j] - m * a[k, j]; if j = n then break;
j:= j + 1;
207
3.4 Массивы
____________________________________________________________________
continue;
end;
b[i]:= b[i] - m * b[k]; if i = n then break; i:= i + 1;
continue;
end;
if k= n - 1 then break; k:= k + 1;
continue;
end;
{Проверка существования решения} if a[n, n] <> 0 then begin
x[n]:= b[n] / a[n, n]; i:= n - 1;
while true do begin
j:= i + 1; S:= 0;
while true do begin
S:= S - a[i, j] * x[j]; if j = n then break; j:= j + 1;
continue;
end;
x[i]:= (b[i] + S) / a[i, i]; if i = 1 then break;
i:= i - 1; continue;
end;
for i:= 1 to n do
writeln('x', i, '= ', x[i]:0:4); end
else
if b[n] = 0 then writeln(UTF8ToConsole('Система уравнений' +
' не имеет решения.'))
else
writeln(UTF8ToConsole('Система уравнений'+ ' имеет бесконечное множество решений.'));
writeln(UTF8ToConsole('Нажмите любую клавишу'));
208
Глава 3 Более сложные элементы языка
____________________________________________________________________
readkey;
end.
3.4.1.3. Вариант 3 – наилучшая реализация
program Gauss_console_app; {$mode objfpc}{$H+}
uses
CRT, FileUtil; var
a:array of array of real; {матрица коэффициентов системы, двумерный динамический массив}
vector: array of real; {преобразованный одномерный динамический массив}
b:array of real;
x: array of real; i, j, k, n: integer;
procedure gauss(var vector: array of real; var b: array of real;
var x: array of real; var n: integer);
var
a: array of array of real; {матрица коэффициентов системы, двумерный динамический массив}
i, j, k, p, r: integer; m, s, t: real;
begin
SetLength(a, n, n); // установка фактического размера массива {Преобразование одномерного массива в двумерный}
k:=1;
for i:=0 to n-1 do for j:=0 to n-1 do begin
a[i,j]:= vector[k]; k:=k+1;
end;
for k:=0 to n-2 do begin
for i:=k+1 to n-1 do begin
if (a[k,k]=0) then begin
{перестановка уравнений}
209
3.4 Массивы
____________________________________________________________________
p:=k; // в алгоритме используется буква l, но она похожа на 1 // Поэтому используем идентификатор p
for r:=i to n-1 do begin
if abs(a[r,k]) > abs(a[p,k]) then p:=r; end;
if p<>k then begin
for j:= k to n-1 do begin
t:=a[k,j];
a[k,j]:=a[p,j];
a[p,j]:=t;
end;
t:=b[k];
b[k]:=b[p];
b[p]:=t;
end;
end; // конец блока перестановки уравнений m:=a[i,k]/a[k,k];
a[i,k]:=0;
for j:=k+1 to n-1 do begin
a[i,j]:=a[i,j]-m*a[k,j]; end;
b[i]:= b[i]-m*b[k]; end;
end;
{Проверка существования решения} if a[n-1,n-1] <> 0 then begin
x[n-1]:=b[n-1]/a[n-1,n-1]; for i:=n-2 downto 0 do begin
s:=0;
for j:=i+1 to n-1 do begin
s:=s-a[i,j]*x[j]; end;
x[i]:=(b[i] + s)/a[i,i]; end;
writeln(''); writeln(UTF8ToConsole('Решение:'));
210
Глава 3 Более сложные элементы языка
____________________________________________________________________
writeln('');
for i:=0 to n-1 do
writeln('x', i+1, '= ', x[i]:0:4); end
else
if b[n-1] = 0 then writeln(UTF8ToConsole('Система не имеет решения.'))
else
writeln(UTF8ToConsole('Система уравнений'+ ' имеет бесконечное множество решений.'));
writeln(''); {освобождение памяти,
распределенной для динамического массива} a:=nil;
end;
{Начало основной программы} begin
{Ввод коэффициентов расширенной матрицы} writeln(UTF8ToConsole('Введите количество неизвестных')); readln(n);
{Установка реальных размеров динамических массивов} SetLength(a, n, n);
SetLength(vector, n*n); SetLength(b, n); SetLength(x, n);
{в динамических массивах индексы начинаются с нуля} for i:=0 to n-1 do
begin
for j:=0 to n-1 do begin
writeln(UTF8ToConsole('Введите a'), i+1, j+1); readln(a[i,j]);
end;
writeln(UTF8ToConsole('Введите b'), i+1); readln(b[i]);
end;
{Преобразование двумерного массива в одномерный} k:=1;
for i:=0 to n-1 do for j:=0 to n-1 do begin
vector[k]:=a[i,j];
211
3.4 Массивы
____________________________________________________________________
k:=k+1;
end;
{Вызов процедуры решения системы линейных алгебраических уравнений методом Гаусса} gauss(vector, b, x, n); {освобождение памяти, распределенной для динамических массивов} a:=nil;
vector:=nil;
x:=nil;
b:=nil;
writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;
end.
Обратите внимание, что массив "a" в главной программе и массив "a" в проце-
дуре это разные массивы, в том смысле, что они будут при выполнении про-
граммы занимать совершенно разные участки памяти. Хотя по смыслу задачи это одна и та же матрица коэффициентов, поэтому им присвоено одинаковое имя. Перед передачей матрицы коэффициентов в процедуру двумерный массив преобразуется в одномерный, который и передается, а внутри процедуры одно-
мерный массив преобразуется обратно в двумерный массив с именем "а".
В принципе, можно реализовать алгоритм и с одномерным массивом,
главное не запутаться в индексах. Предлагаю вам самим написать такую про-
грамму. Организуйте ввод коэффициентов системы сразу в одномерный дина-
мический массив и реализуйте с ним алгоритм метода Гаусса.
Общим недостатком всех трех программ является отсутствие контроля при вводе коэффициентов системы. Однако это сделано намеренно, чтобы не отвле-
каться от сути задачи и не загромождать программы излишними деталями.
Программы и так получаются достаточно большими. Вы можете самостоятель-
но вставить проверку при вводе, используя способы, изложенные в 2.1.25. Бо-
лее продвинутые и профессиональные способы контроля мы будем рассматри-
вать в главе 6.
212