Иерархические списки как АТД

В предыдущей главе обсуждался рекурсивный подход к определению и обработке линейных списков. В продолжение темы расширим данный подход, введя понятие «иерархический список». Иерархические списки имеют и другие названия. Так, в классической работе Кнута [8] они называются Списками (с заглавной буквы) и рассматриваются как одна из наиболее универсальных структур данных.

Основная область использования иерархических списков — функциональное программирование, где они называются S-выражениями (Symbolic Expression).

Чтобы быстрее понять суть дела, сначала дадим неформальное определение понятия «иерархический список». Представим себе, что содержательная часть любого элемента линейного связного списка может содержать или данные (значения базового типа, которые в этом случае называются атомами), или указатель (ссылку) на другой список. Элементы этого вложенного списка также могут содержать указатели на другие списки. Так образуется иерархическая структура. Пример такой структуры изображен на рис. 3.1

 

Рис.3.1. Пример иерархического списка

Здесь a,b,c,d,e — значения базового типа. Первый и последний элементы списка содержат атомы a и e (значения базового типа), второй элемент — указатель на список. Первый элемент этого вложенного списка — указатель на пустой список (это допустимо в иерархических списках), второй содержит указатель на линейный список, содержащий два атома b и c. Последний элемент вложенного списка содержит атом d.

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

Используя аналогию с разделом 2.6, данный иерархический список можно компактно представить в виде скобочного выражения (a.(().(b.c).d).e). Здесь конструкция () обозначает пустой список.

Перейдем к формальному рекурсивному определению иерархического списка (S-выражения) [2].

S-выражение представляет собой или элемент базового типа, называемый в этом случае атомом (атомарным S–выражением), или линейный список из S–выражений (возможно пустой).

Непустой линейный список из S –выражений представим как точечную пару "голова"–"хвост" по аналогии с разделом 2.6, с той разницей, что голова является S-выражением, а хвост — линейный список S-выражений (в непустом линейном списке голова — всегда атом, хвост — линейный список атомов).

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

В таблице 3.1 показаны примеры иерархических списков, представляющие списки в полной и сокращенной скобочной записи. Переход к сокращенной записи произведен по правилам, изложенным в 2.6.

Таблица 3.1.

Примеры иерархических списков

Полная запись	Сокращенная запись	Комментарий
a Nil (a. (b. (c. nil)))   (a.((b.(c. nil)).(d.(e. nil))))	a () (a.b.c)   (a.(b.c).d.e)	Атомарное S-выражение Пустое S-выражение Частный случай — линейный список S-выражение иерархической структуры

 

Зададим функциональную спецификацию иерархических списков, воспользовавшись базовыми функциями (операциями) в тех же обозначениях, как было принято при определении линейных списков в разделе 2.6. По сравнению с линейными списками ситуация усложняется необходимостью отличать атомарные S-выражения от неатомарных. Введем следующие обозначения. Пусть

S_expr(α) — произвольное S-выражение (атомарное или неатомарное), где α — базовый тип данных;

Atomic (α) — атомарное S-выражение, согласно определению, представляет собой произвольное значение типа α, при этом является частью типа S_expr(α);

List(S_expr(α)) — линейный список (возможно, и пустой) из S-выражений (т. е. неатомарное S-выражение);

Non_null_list(S_expr(α)) — непустое неатомарное S-выражение;

Null_list(S_expr(α)) — пустое S-выражение (не является атомом).

Базовые функции IsNull, Head, Tail, Cons применительно к иерархическим спискам имеют тот же смысл, что и для линейных списков (проверить на пустоту, разобрать список, выделив голову и хвост, и собрать список из головы и хвоста). Для проверки S-выражения на атомарность вводится предикат IsAtom.

Две дополнительных функции (назовем их MakeAtom и GetAtom) придется добавить к функциональной спецификации в связи с необходимостью приведения базового типа данных α к типу атомарного S-выражения Atomic (α) и выполнения обратного преобразования. Данные функции носят вспомогательеый характер и потребуются при реализации АТД на языке высокого уровня.     

Таким образом, формальная функциональная спецификация АТД «Иерархический список (S-выражение)» будет иметь вид:

0) nil: ® Null_list(S_expr(α));

1) IsNull: List(S_expr(α)) ® Boolean;

2) Head: Non_null_list(S_expr(α)) ® S_expr(α);

3) Tail: Non_null_list(S_expr(α)) ® List(S_expr(α));

4) Cons: S_expr(α)ÄList(S_expr(α)) ®

         Non_null_list(S_expr(α));

5) IsAtom:    S_expr(α) ® Boolean;

6) MakeAtom: α ® Atomic (α);

7) GetAtom: Atomic (α) ® α.

Для уточнения смысла каждой функции зададим систему правил (аксиом) А1–А7, справедливых для всех t типа α, всех u типа List(S_expr(α)), всех v типа Non_null_list(S_expr(α)), всех w типа S_expr(α):

A1) IsNull (nil) = true;

A2) IsNull (Cons (w, u)) = false;

A3) Head (Cons (w, u)) = w;

A4) Tail (Cons (w, u)) = u;

A5) Cons (Head(v), Tail(v)) = v;

A6) IsAtom (MakeAtom(t)) = true;

A7) IsAtom (u) = false;

A8) GetAtom (MakeAtom(t)) = t.

Как и в случае линейных списков, для создания пустого списка в функциональной спецификации введена функция без параметров nil. Обратим внимание, что пустой список не является атомом, но результат функции MakeAtom всегда является атомом.

Функции Head и Tail неприменимы к атомарным S-выражениям, однако являются единственным средством доступа к неатомарным S-выражениям. Так, например, если u = (a (b c) d e), то

Head (Tail (u)) = (b c);

Head (Tail (Head (Tail (u)))) =c.

Здесь a, b, c, d, e представляют собой атомарные S-выражения. Для получения данных базового типа, например, значения c, следует применить функцию GetAtom(c).

Формирование списков выполняется только с помощью функции Cons. Например:

 (a (b c) d e) = (a.((b.(c.nil)). (d. (e.nil))))=

Cons(a, Cons(Cons(b,Cons(c, nil)), Cons(d,Cons(e,nil))));

(a (() (b c)d)e) =

(a.((nil. ((b. (c. nil)). (d. nil))). (e. nil))) =

Cons(a, Cons(Cons(nil, Cons(Cons(b, Cons(c,nil)), Cons(d,nil))), Cons(e,nil))). 

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

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