212 |
|
|
|
Глава 12. Структура |
|
|
|
|
|
|
|
(node-r prev) |
(node-l bst)) |
|
|
|
root) |
|
|
|
|
(progn |
|
|
|
|
(setf (node-r bst) |
(node-r root)) |
|
|
|
bst)))) |
|
|
|
(defun replace-node (old new) |
|
||
|
(setf |
(node-elt |
old) (node-elt new) |
|
|
|
(node-l |
old) (node-l |
new) |
|
|
(node-r |
old) (node-r |
new))) |
|
(defun cutmin (bst par dir) |
|
||
|
(if (node-l bst) |
|
|
|
|
(cutmin (node-l bst) bst :l) |
|||
|
(progn |
|
|
|
|
|
(set-par par dir (node-r bst)) |
||
|
|
(node-elt bst)))) |
|
|
|
(defun cutmax (bst par dir) |
|
||
|
(if (node-r bst) |
|
|
|
|
(cutmax (node-r bst) bst :r) |
|||
|
(progn |
|
|
|
|
|
(set-par par dir (node-l bst)) |
||
|
|
(node-elt bst)))) |
|
|
|
(defun set-par (par dir val) |
|
||
|
(case |
dir |
|
|
|
(:l |
(setf (node-l par) val)) |
|
|
|
(:r |
(setf (node-r par) val)))) |
||
|
|
|
|
|
Рис. 12.9. Двоичные деревья поиска: деструктивное удаление
12.6. Пример: двусвязные списки
Обычные списки в Лиспе являются односвязными. Это означает, что движение по указателям происходит только в одном направлении: вы можете перейти к следующему элементу, но не можете вернуться к пре дыдущему. Двусвязные списки имеют также и обратный указатель, по этому можно перемещаться в обе стороны. В этом разделе показано, как создавать и использовать двусвязные списки.
На рис. 12.10 показана их возможная реализация. cons-ячейки имеют два поля: car, указывающий на данные, и cdr, указывающий на следую щий элемент. Элемент двусвязного списка должен иметь еще одно поле, указывающее на предыдущий элемент. Вызов defstruct (рис. 12.10) соз дает объект из трех частей, названный dl (от «doubly linked»), который мы будем использовать для создания двусвязных списков. Поле data в dl соответствует car в cons-ячейке, а поле next соответствует cdr. Поле
12.6. Пример: двусвязные списки |
213 |
prev похоже на cdr, но указывает в обратном направлении. (Пример та кой структуры приведен на рис. 12.11.) Пустому двусвязному списку, как и обычному, соответствует nil.
Вызов defstruct также определяет функции для двусвязных списков, аналогичные car, cdr и consp: dl-data, dl-next и dl-p. Функция печати dl->list возвращает обычный список с теми же значениями, что и дву связный.
Функция dl-insert похожа на cons. По крайней мере, она, как и cons, яв ляется основной функцией-конструктором. В отличие от cons, она изме няет двусвязный список, переданный вторым аргументом. В данной си туации это совершенно нормально. Чтобы поместить новый объект в на чало обычного списка, вам не требуется его изменять, однако чтобы по местить объект в начало двусвязного списка, необходимо присвоить полю prev указатель на новый объект.
(defstruct (dl (:print-function print-dl)) prev data next)
(defun print-dl (dl stream depth) (declare (ignore depth))
(format stream "#<DL ~A>" (dl->list dl)))
(defun dl->list (lst) (if (dl-p lst)
(cons (dl-data lst) (dl->list (dl-next lst))) lst))
(defun dl-insert (x lst)
(let ((elt (make-dl :data x :next lst))) (when (dl-p lst)
(if (dl-prev lst)
(setf (dl-next (dl-prev lst)) elt (dl-prev elt) (dl-prev lst)))
(setf (dl-prev lst) elt)) elt))
(defun dl-list (&rest args) (reduce #’dl-insert args
:from-end t :initial-value nil))
(defun dl-remove (lst) (if (dl-prev lst)
(setf (dl-next (dl-prev lst)) (dl-next lst))) (if (dl-next lst)
(setf (dl-prev (dl-next lst)) (dl-prev lst))) (dl-next lst))
Рис. 12.10. Построение двусвязных списков
214 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Глава 12. Структура |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nil |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
nil |
|
|
|
|
|
|
|
|
||||||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
a |
b |
|
|
|
c |
||||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Рис. 12.11. Двусвязный список
Другими словами, несколько обычных списков могут иметь общий хвост. Но для пары двусвязных списков это невозможно, так как хвост каждого из них имеет разные указатели на голову. Если бы функция dl-insert не была деструктивна, ей бы приходилось всегда копировать свой второй аргумент.
Другое интересное различие между одно- и двусвязными списками за ключается в способе доступа к их элементам. Работая с односвязным списком, вы храните указатель на его начало. При работе с двусвязным списком, поскольку в нем элементы соединены с обоих концов, вы мо жете использовать указатель на любой из элементов. Поэтому dl-insert, в отличие от cons, может добавлять новый элемент в любое место дву связного списка, а не только в начало.
Функция dl-list является dl-аналогом list. Она получает произвольное количество аргументов и возвращает состоящий из них dl:
> (dl-list ’a ’b ’c) #<DL (A B C)>
В ней используется reduce с параметрами: :from-end, установленным в t, и :initial-value, установленным в nil, что делает приведенный выше вызов эквивалентным следующей последовательности:
(dl-insert ’a (dl-insert ’b (dl-insert ’c nil)))
Заменив #’dl-insert на #’cons в определении dl-list, эта функция будет вести себя аналогично list:
>(setf dl (dl-list ’a ’b)) #<DL (A B)>
>(setf dl (dl-insert ’c dl)) #<DL (C A B)>
>(dl-insert ’r (dl-next dl)) #<DL (R A B)>
>dl
#<DL (C R A B)>
Наконец, для удаления элемента из двусвязного списка определена dl-remove. Как и dl-insert, она сделана деструктивной.
12.7. Циклическая структура |
215 |
12.7. Циклическая структура
Изменяя структуру списков, можно создавать циклические списки. Они бывают двух видов. Наиболее полезными являются те, которые имеют замкнутую структуру верхнего уровня. Такие списки называются цик лическими по хвосту (cdr-circular), так как цикл создается cdr-частями ячеек.
Чтобы создать такой список, содержащий один элемент, необходимо установить указатель cdr на самого себя:
>(setf x (list ’a))
(A)
>(progn (setf (cdr x) x) nil) NIL
Теперь x – циклический список. Его структура изображена на рис. 12.12.
x = |
y = |
nil |
a
Рис. 12.12. Циклические списки
При попытке напечатать такой список символ a будет выводиться до бесконечности. Этого можно избежать, установив значение *print-circ le* в t:
>(setf *print-circle* t)
T
>x
#1=(A . #1#)
При необходимости можно использовать макросы чтения #n= и #n# для представления такой структуры.
Списки с циклическим хвостом могут быть полезны для представле ния, например, буферов или ограниченных наборов каких-то объектов (пулов1). Следующая функция превратит произвольный нецикличе ский непустой список в циклический с теми же элементами:
(defun circular (lst)
(setf (cdr (last lst)) lst))
1Пул – это набор инициализированных ресурсов, которые поддерживаются в готовом к использованию состоянии, а не выделяются по требованию. –
Прим. ред.
216 |
Глава 12. Структура |
Другой тип циклических списков – циклические по голове (car-circular). Список такого типа можно понимать как дерево, являющееся поддере вом самого себя. Его название обусловлено тем, что в нем содержится цикл, замкнутый на car ячейки. Ниже мы создадим циклический по голове список, второй элемент которого является им самим:
> (let ((y (list ’a))) (setf (car y) y) y)
#1=(#1#)
Результат изображен на рис. 12.12. Несмотря на цикличность, этот цик лический по голове список (car-circular) по-прежнему является пра вильным списком, в отличие от циклических по хвосту (cdr-circular), которые правильными быть не могут.
Список может быть циклическим по голове и хвосту одновременно. car и cdr такой ячейки будут указывать на нее саму:
> (let ((c (cons 1 1))) (setf (car c) c
(cdr c) c)
c)
#1=(#1# . #1#)
Сложно представить, для чего могут использоваться подобные объек ты. На самом деле, главное, что нужно вынести из этого, – необходимо избегать непреднамеренного создания циклических списков, так как большинство функций, работающих со списками, будут уходить в бес конечный цикл, если получат в качестве аргумента список, цикличе ский по тому направлению, по которому они совершают проход.
Циклическая структура может быть проблемой не только для списков, но и для других типов объектов, например для массивов:
>(setf *print-array* t)
T
>(let ((a (make-array 1))) (setf (aref a 0) a)
a)
#1=#(#1#)
И действительно, практически любой объект, состоящий из элементов, может включать себя в качестве одного из них.
Разумеется, структуры, создаваемые defstruct, также могут быть цик лическими. Например, структура c, представляющая элемент дерева, может иметь поле parent, содержащее другую структуру p, чье поле child ссылается обратно на c:
> (progn (defstruct elt
(parent nil) (child nil)) (let ((c (make-elt))
(p (make-elt)))