Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

Дерево:=правое поддерево

Рис. 4.23 Алгоритм обхода двоичного дерева слева

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

Память компьютера состоит из ячеек, называемых байтами. Каждый байт имеет свой номер или иначе адрес. Нумерация идет от 0 до N-1. Где N объем оперативной памяти. Если мы хотим записать в память компьютера значение некоторой переменной, то мы не указываем конкретный адрес, куда должно быть записано значение переменной. Мы просто даем этой переменной имя, т.е.

обозначаем ее, например А. Компилятор отведет этой переменной нужное ко-

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

337

4.3 Динамические структуры данных

____________________________________________________________________

сом переменной считается адрес ее первого байта. Таким образом, под А мы подразумеваем не само значение переменной, а ее адрес (адрес первого байта).

Хотя в программе мы пишем, например А:= 28; на самом деле мы говорим компьютеру: запиши в байты памяти начиная с номера А число 28. Перемен-

ной А компилятор отведет четыре подряд расположенных байта, поскольку число 28 является целым.

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

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

– целый, т.е. каждый его элемент это целые числа.

Тогда компилятор отведет под этот массив 20*4=80 байтов. Причем для обращения к отдельным элементам массива используется индекс M[1], M[I],B[I+K], т.е. в этом случае адрес состоит из двух частей: одна часть ука-

зывает на начало всей совокупности, отводимой для массива, а другая – адрес байта относительно начала совокупности. Обычно адрес начала совокупности называют базовым адресом, а адрес байта относительно начала совокупности – смещением.

Таким образом:

Полный адрес = базовый адрес + смещение

338

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

Байты памяти

0

Переменной А отведено 4 байта.

Массиву М отведено

20х4 = 80 байтов.

N-1

Рис. 4.24. Схема распределения памяти переменной А и массиву М

Такая совокупность называется вектором памяти. В языке Pascal масси-

вы (как одномерные, так и многомерные) представляются векторами.

Но можно использовать и другой способ представления информации.

Как известно, последовательности байтов памяти мы можем интерпрети-

ровать как угодно, в частности их можно интерпретировать как адрес некото-

рой другой совокупности байтов. Например, значение переменной A: <А> = 2000← можно считать адресом

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

вается указателем, а адрес, на который указывает указатель, называется звеном.

Если имеется некоторая последовательность указателей и звеньев, то ее назы-

вают цепочкой или сцеплением звеньев.

Рассмотрим простейшую структуру сцепления – связанный список. Пред-

ставим, например, с помощью связанного списка строку символов "МАМА".

339

4.3 Динамические структуры данных

____________________________________________________________________

Признак конца списка

Рис. 4.25. Связанный список

Как видно из рисунка связанный список состоит из двух полей. Первое по-

ле содержит непосредственно сам элемент списка. Второе поле – указатель на следующий элемент списка. Причем поле указателя последнего элемента спи-

ска содержит специальный признак конца списка – nil.

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

Связанные списки еще называют линейными списками.

Стек и деревья можно реализовать как с помощью векторов памяти (мас-

сивов), так и с помощью линейных списков, используя указатели.

4.3.2 Реализация стека с помощью массивов

Напишем программу работы со стеком. Существует всего две операции со стеком – поместить элемент в стек и извлечь элемент из стека. Используются также термины втолкнуть (затолкнуть) элемент в стек и вытолкнуть элемент из стека. Процедуру, реализующую операцию помещения элемента в стек назовем

Put_Stack, а процедуру, реализующую процесс извлечения элемента из стека

– Take_Stack. Вполне можно было бы назвать эти процедуры и Push_Stack,

340

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

Pop_Stack. Сначала реализуем стек с помощью массива, рисунок 4.26.

N Глубина стека Рис. 4.26 Реализация стека на основе массивов.

Из рисунка видно, что для реализации стека нам нужны два массива, мас-

сив-указатель, назовем его ukaz[1..3] и массив-тело стека, назовем его

CTEK. Для определенности пусть он состоит из 100 элементов, т.е. глубина сте-

ка равна 100 элементам. Пусть, также для определенности, элементами стека являются просто целые числа. На практике элементами стека могут являться и более сложные структуры, например, записи. В массиве ukaz первый элемент,

т.е. ukaz[1] содержит индекс массива СТЕК, равный началу стека, обычно это

1. Элемент ukaz[3] содержит индекс массива СТЕК, равный концу стека, т.е.

заданной глубине стека N = 100 и обычно совпадает с максимальным размером массива СТЕК. Элемент массива ukaz[2] – это индекс в массиве СТЕК, куда будет помещен новый элемент стека, а ukaz[2]-1 это индекс, по которому из

СТЕК можно будет взять последний помещенный в него элемент.

Программа будет выводить на экран меню, с помощью которого можно помещать новый элемент в стек, брать элемент из верхушки стека и просматри-

341

4.3 Динамические структуры данных

____________________________________________________________________

вать весь массив стека.

program project1; {$mode objfpc}{$H+} uses

CRT, FileUtil; const

SizeOfArray = 100; type

c= array[1..SizeOfArray] of integer; u= array[1..3] of integer;

var

choose: integer; EMPTY: boolean; ERROR: boolean; CTEK: c;

ukaz: u; ELEM: integer;

{ ================================================= } procedure Put_Stack(var ELEM: integer; var CTEK: c;

var ukaz: u; var ERROR: Boolean); { ================================================= }

var k: integer; begin

if ukaz[2] > ukaz[3] then ERROR:= true

else begin

342

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

k:= ukaz[2]; CTEK[k]:= ELEM; ukaz[2]:= k + 1;

end;

end;

{ ================================================== } procedure Take_Stack(var ELEM: integer; var CTEK: c;

var ukaz: u; var EMPTY: Boolean); { ================================================== } var k: integer;

begin

if ukaz[2] <= ukaz[1] then EMPTY:= true

else begin

k:= ukaz[2] - 1; ELEM:= CTEK[k]; ukaz[2]:= k;

end;

end;

procedure View_Stack(var CTEK: c; var ukaz: u); var

i: integer; begin

writeln(UTF8ToConsole('Массив стека')); for i:= 1 to ukaz[2] - 1 do

write(CTEK[i], ' '); writeln;

343

4.3 Динамические структуры данных

____________________________________________________________________

end;

begin

{Инициализация стека}

ukaz[1]:= 1;

ukaz[2]:= 1;

ukaz[3]:= SizeOfArray;

repeat

EMPTY:= false;

ERROR:= false;

writeln(UTF8ToConsole('Выберите нужный режим работы :'));

writeln(UTF8ToConsole('Введите новый элемент стека')); readln(ELEM);

Put_Stack(ELEM, CTEK, ukaz, ERROR); if ERROR then

begin

writeln(UTF8ToConsole('Переполнение стека.')); writeln(UTF8ToConsole('Увеличьте размер массива')); writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;

end;

end;

344

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

2: begin

Take_Stack(ELEM, CTEK, ukaz, EMPTY); if EMPTY then

writeln(UTF8ToConsole('Стек пуст')) else

writeln(UTF8ToConsole('Из стека взят элемент '), ELEM);

end;

3: View_Stack(CTEK, ukaz); end; { end of case }

until choose = 4; end.

Процедура Put_Stack просто помещает новый элемент в массив СТЕК по индексу ukaz[2] и затем увеличивает значение этого индекса на единицу.

Перед этим процедура проверяет стек на переполнение, т.е. не перешли ли мы за пределы массива СТЕК.

Процедура Take_Stack возвращает элемент массива СТЕК с индексом ukaz[2]-1 и уменьшает значение индекса на единицу. Перед этим она прове-

ряет не пуст ли уже стек.

Если внимательно присмотреться к процедурам Put_Stack и Take_Stack, то возникает вполне резонный вопрос, а зачем, собственно гово-

ря, здесь нужен массив-указатель ukaz? И мы будем абсолютно правы. При реализации стека вполне можно обходиться одним массивом, только для раз-

мещения элементов стека. А в качестве указателя использовать простую цело-

численную переменную, которую назовем также ukaz. Вот листинг другой,

улучшенной реализации стека:

345

4.3 Динамические структуры данных

____________________________________________________________________

program modify_stack; {$mode objfpc}{$H+} uses

CRT, FileUtil; const

SizeOfArray = 100; type

c= array[1..SizeOfArray] of integer; var

choose: integer; EMPTY: boolean; ERROR: boolean; CTEK: c;

ukaz: integer; ELEM: integer;

{ =================================================== } procedure Put_Stack(var ELEM: integer; var CTEK: c;

var ukaz: integer; var ERROR: Boolean); { =================================================== }

begin

if ukaz > SizeOfArray then ERROR:= true

else begin

CTEK[ukaz]:= ELEM; ukaz:= ukaz + 1;

end;

end;

346

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

{ ================================================== } procedure Take_Stack(var ELEM: integer; var CTEK: c;

var ukaz: integer; var EMPTY: Boolean); { ================================================== }

begin

if ukaz = 1 then EMPTY:= true

else begin

ukaz:= ukaz - 1; ELEM:= CTEK[ukaz];

end;

end;

procedure View_Stack(var CTEK: c; var ukaz: integer); var

i: integer; begin

writeln(UTF8ToConsole('Массив стека')); for i:= 1 to ukaz - 1 do

write(CTEK[i], ' '); writeln;

end;

begin

{Инициализация указателя стека (начального индекса в массиве)}

ukaz:= 1;

repeat

EMPTY:= false;

347

4.3 Динамические структуры данных

____________________________________________________________________

ERROR:= false;

writeln(UTF8ToConsole('Выберите нужный режим работы :'));

writeln(UTF8ToConsole('Введите новый элемент стека')); readln(ELEM);

Put_Stack(ELEM, CTEK, ukaz, ERROR); if ERROR then

begin

writeln(UTF8ToConsole('Переполнение стека.')); writeln(UTF8ToConsole('Увеличьте размер массива')); writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;

end;

end; 2: begin

Take_Stack(ELEM, CTEK, ukaz, EMPTY); if EMPTY then

writeln(UTF8ToConsole('Стек пуст')) else

writeln(UTF8ToConsole('Из стека взят элемент '),

ELEM);

end;

3: View_Stack(CTEK, ukaz);

348

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

end; { end of case }

until choose = 4;

end.

В этой реализации переменная ukaz является индексом (указателем) вер-

хушки стека и одновременно показывает количество элементов в стеке, т.е. оп-

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

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

должна уменьшить значение ukaz на единицу и возвратить элемент с индексом ukaz. Таким образом, указатель (индекс в массиве) расположен так, как пока-

зано на рисунке 4.26.

Существенным недостатком представления стека векторным способом яв-

ляется необходимость задания максимальной глубины стека, поскольку не все-

гда известна точная глубина стека. Отсюда необходимость задания глубины стека с "запасом", т.е. память используется нерационально. Достоинство – от-

носительная простота работы со стеком.

4.3.3 Представление двоичного дерева в виде массива и реализация алго-

ритма обхода двоичного дерева слева.

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

Поэтому крайне необходимо освоить технику работы с ними. Здесь мы рас-

смотрим представление дерева с помощью массива.

Пусть имеется дерево, рис. 4.27.

349

4.3 Динамические структуры данных

____________________________________________________________________

Рис. 4.27. Двоичное дерево. В качестве вершин выступают целые числа

В этом дереве вершинами являются просто целые числа, хотя в качестве вершин могут выступать любые объекты. Представим наше дерево в виде, рис.

4.28. Отсюда возникает идея хранить в массиве не только саму вершину, но и индексы левого и правого поддерева. Таким образом, каждый элемент массива представляет собой тройку чисел – корень и индексы в массиве левого и право-

го поддерева. Если левое или правое поддеревья пустые, то индекс равен -1

(аналог nil).

1

8 x x 9 x x 10 x x 11 x x 12 x x 13 x x 14 x x 15 x x

Рис. 4.28. Схема представления двоичного дерева с помощью массива

Внимательно присмотритесь к рисунку. Фактически это похоже на связан-

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

ставление этого же дерева с помощью "настоящего" связанного списка и указа-

350

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

телей мы рассмотрим в следующем разделе. Для того чтобы записать индексы на левые и правые поддеревья в массиве поступим следующим образом: если вершина – корень имеет номер индекса n, то левое и правое поддерево – соот-

ветственно 2*n и 2*n+1. Нумерация начинается с n=1. Ячейка со значением -1

обозначает отсутствие вершины. Сначала сделаем вручную распределение ин-

дексов в массиве для нашего дерева, табл. 4.1.

Визуально массив, реализующий наше исходное двоичное дерево можно представить следующим образом, рис. 4.29.

351

4.3 Динамические структуры данных

____________________________________________________________________

При обходе этого двоичного дерева слева последовательность обработки вершин будет следующей:

8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15

Блок схему алгоритма обхода мы с вами уже рассматривали, см. рис. 4.23.

Последовательность состояний стека для данного алгоритма будет сле-

дующей, рис. 4.30:

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

352

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

редакторе "Блокнот" (NotePad) файл представления двоичного дерева в виде массива приведенного в таблице 4.1 с именем "derevo.dat" и разместите его в папке с проектом. Можете взять готовый файл из прилагаемого к книге DVD

диска. В соответствии со структурой массива будем использовать запись вида:

type

T = record

TElem: integer;

TLeft: integer;

TRight: integer;

end;

Где T – элемент массива типа запись, TElem вершина дерева, TLeft ин-

декс в массиве левого поддерева, TRight индекс в массиве правого поддерева.

Чтобы не загромождать текст основной программы, процедуры

Put_Stack и Take_Stack оформим в виде отдельного модуля STACK.

Текст модуля:

unit STACK; interface const

SizeOfArrayCTEK= 100;

SizeOfArrayDER= 100;

type

T = record

TElem: integer;

TLeft: integer;

TRight: integer;

end;

353

4.3 Динамические структуры данных

____________________________________________________________________

procedure Put_Stack(var ELEM: integer; var CTEK: array of T; var ukaz: integer; var ERROR: Boolean);

procedure Take_Stack(var ELEM: integer; var CTEK: array of T; var ukaz: integer; var EMPTY: Boolean);

implementation

{ ======================================== } procedure Put_Stack(var ELEM: integer;

var CTEK: array of T;

var ukaz: integer;

var ERROR: Boolean);

{======================================== } begin

if ukaz > SizeOfArrayCTEK then ERROR:= true

else begin

CTEK[ukaz].TElem:= ELEM; ukaz:= ukaz + 1;

end;

end;

{====================================== } procedure Take_Stack(var ELEM: integer;

var CTEK: array of T;

var ukaz: integer;

354

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

var EMPTY: Boolean); { ====================================== } begin

if ukaz = 1 then EMPTY:= true

else begin

ukaz:= ukaz - 1;

ELEM:= CTEK[ukaz].TElem; end;

end;

end.

Листинг программы обхода двоичного дерева слева:

program Derevo_Left;

{$mode objfpc}{$H+}

{Процедуры работы со стеком мы оформили в виде модуля!} uses

CRT, FileUtil, STACK; var

CTEK:array [1..SizeOfArrayCTEK] of T; DER:array[1..SizeOfArrayDER] of T; ukaz: integer;

i ,ELEM: integer; ERROR, EMPTY: Boolean; fder: TextFile;

begin

{Инициализация указателя стека (начального индекса в массиве)}

ukaz:= 1;

355

4.3 Динамические структуры данных

____________________________________________________________________

{Чтение из файла дерева} Assign(fder, 'derevo.dat'); Reset(fder);

i:= 1;

while not Eof(fder) do begin

Read(fder, DER[i].TElem);

Read(fder, DER[i].TLeft);

Read(fder, DER[i].TRight); inc(i);

end;

Close(fder); ERROR:= false; EMPTY:= false; i:= 1;

writeln(UTF8ToConsole('Обход двоичного дерева слева')); while DER[i].TElem <> -1 do

begin

if DER[i].TLeft <> -1 then begin

ELEM:= i;

Put_Stack(ELEM, CTEK, ukaz, ERROR); if ERROR = true then

begin

writeln(UTF8ToConsole('Ошибка! Переполнение стека.')); writeln(UTF8ToConsole('Увеличьте размер массива')); writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;

exit;

356

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

end;

i:= DER[i].TLeft; end

else begin

repeat writeln(DER[i].TElem);

Take_Stack(ELEM,CTEK,ukaz,EMPTY); if EMPTY = true then break;

i:= ELEM;

until DER[i].TRight <> -1; if EMPTY = true then break; writeln(DER[i].TElem);

i:= DER[i].TRight; end;

end;

writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;

end.

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

program Derevo_Left;

{$mode objfpc}{$H+}

{Процедуры работы со стеком мы оформили в виде модуля!}

uses

CRT, FileUtil, STACK;

var

CTEK: array [1..SizeOfArrayCTEK] of T;

DER: array[1..SizeOfArrayDER] of T;

357

4.3 Динамические структуры данных

____________________________________________________________________

ukaz: integer;

i,ELEM:integer;

ERROR, EMPTY: Boolean;

k: integer;

answ: char;

begin

{Ввод дерева}

writeln(UTF8ToConsole('Вводите дерево строго')); writeln(UTF8ToConsole('сверху вниз и слева направо')); writeln(UTF8ToConsole('Чтобы закончить ввод введите -1'));

i:= 1;

while true do

begin

writeln(UTF8ToConsole('Введите корень.'));

{$i-} // отключение стандартного режима контроля ввода repeat

ERROR:= false; readln(k);

ERROR:= (IoResult <> 0);

if ERROR then {если ERROR=true, значит произошла ошибка при

вводе}

writeln(UTF8ToConsole('Ошибка! Введите номер вершины')); until not ERROR;

{$+} // восстановление стандартного режима контроля ввода/вывода

DER[i].TElem:= k; if k = -1 then begin

DER[i].TLeft:= -1;

DER[i].TRight:= -1;

358

Глава 4 Типовые алгоритмы обработки информации

____________________________________________________________________

break;

end;

writeln(UTF8ToConsole('Текущая вершина имеет поддеревья?'));

writeln(UTF8ToConsole('Ответ (y/n)')); repeat

readln(answ);

if (answ = 'y') then begin

DER[i].TLeft:= 2 * i;

DER[i].TRight:= 2 * i + 1;

end else begin

DER[i].TLeft:= -1;

DER[i].TRight:= -1; end;

until (answ = 'n') or (answ = 'y'); inc(i);

end;

{Обход заданного двоичного дерева слева} {Инициализация указателя стека (начального индекса в массиве)}

ukaz:= 1;

ERROR:=false;

EMPTY:=false;

i:= 1;

writeln(UTF8ToConsole('Обход двоичного дерева слева'));

while DER[i].TElem <> -1 do

begin

if DER[i].TLeft <> -1 then

359

4.3 Динамические структуры данных

____________________________________________________________________

begin ELEM:= i;

Put_Stack(ELEM,CTEK,ukaz,ERROR); if ERROR = true then

begin

writeln(UTF8ToConsole('Ошибка! Переполнение стека.')); writeln(UTF8ToConsole('Увеличьте размер массива')); writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey; exit;

end;

i:= DER[i].TLeft; end

else begin

repeat writeln(DER[i].TElem);

Take_Stack(ELEM, CTEK, ukaz, EMPTY); if EMPTY = true then break;

i:= ELEM;

until DER[i].TRight <> -1; if EMPTY=true then break; writeln(DER[i].TElem);

i:= DER[i].TRight; end;

end;

writeln(UTF8ToConsole('Нажмите любую клавишу')); readkey;

end.

Намучились с вводом дерева? Действительно, муторное это занятие. К сча-

360