Жанр: Учеба
Программирование в теоремах и задачах
...очтя некоторое начало X входного слова, мы будем
помнить множество всех вершин источника, в которые можно пройти
из начальной, прочитав на пути слово X.
Оказывается, что регулярные выражения, автоматы и источники
распознают одни и те же множества. Чтобы убедиться в этом, нам
осталось решить такую задачу:
10.7.11. Дан источник. Построить регулярное выражение, задающее
то же множество, что и этот источник.
Решение. (Сообщено участниками просеминара по логике.)
Пусть источник имеет вершины 1..k. Будем считать, что 1 - это
начало, а k - конец. Через D[i,j, s] обозначим множество всех
слов, которые можно прочесть на пути из i в j, если в качестве
промежуточных пунктов разрешается использовать только вершины
1,...,s. Согласно определению, источнику соответствует множество
D[1,k,k].
Индукцией по s будем доказывать регулярность всех множеств
D[i,j,s] при всех i и j. При s=0 это очевидно (промежуточные
вершины запрещены, поэтому каждое из множеств состоит только из
букв).
Из чего состоит множество D[i,j,s+1]? Отметим на пути моменты,
в которых он заходит в s+1-ую вершину. При этом путь разбивается
на части, каждая из которых уже не заходит в нее. Поэтому
легко сообразить, что
D[i,j,s+1] = (D[i,j,s]| (D[i,s+1,s] D[s+1,s+1,s]* D[s+1,j,s]))
(вольность записи: мы используем для операций над множествами
обозначения как для регулярных выражений). Остается воспользоваться
предположением индукции.
10.7.12. Где еще используется то же самое рассуждение?
Ответ. В алгоритме Флойда вычисления цены кратчайшего пути,
см. главу 9 (Некоторые алгоритмы на графах).
10.7.13. Доказать, что класс множеств, задаваемых регулярными
выражениями, не изменился бы, если бы мы разрешили использовать
не только объединение, но и отрицание (а следовательно,
и пересечение - оно выражается через объединение и отрицание).
Решение. Для автоматов переход к отрицанию очевиден.
Замечание. На практике важную роль играет число состояний
автомата. Оказывается, что тут все не так просто, и переход о
источника к автомату требует экспоненциального роста числа состояний.
Подробное рассмотрение связанных с этим теоретических и
практических вопросов - дело особое.
Глава 11. Представление множеств. Хеширование.
11.1. Хеширование с открытой адресацией
В предыдущей главе было несколько представлений для множеств,
элементами которых являются целые числа произвольной величины.
Однако в любом из них хотя бы одна из операций проверки
принадлежности, добавления и удаления элемента требовала количества
действий, пропорционального числу элементов множества. На
практике это бывает слишком много. Существуют способы, позволяющие
получить для всех трех упомянутых операций оценку C*log n.
Один из таких способов мы рассмотрим в следующей главе. В этой
главе мы разберем способ, которые хотя и приводит к C*n действиям
в худшем случае, но зато "в среднем" требует значительно
меньшего их числа. (Мы не будем уточнять слов "в среднем", хотя
это и можно сделать.) Этот способ называется хешированием.
Пусть нам необходимо представлять множества элементов типа
T, причем число элементов заведомо меньше n. Выберем некоторую
функцию h, определенную на значениях типа T и принимающую значения
0..(n-1). Было бы хорошо, чтобы эта функция принимала на
элементах будущего множества по возможности более разнообразные
значения. Худший случай - это когда ее значения на всех элементах
хранимого множества одинаковы. Эту функцию будем называть
хеш-функцией.
Введем два массива
val: array [0..n-1] of T;
used: array [0..n-1] of boolean;
(мы позволяем себе писать n-1 в качестве границы в определении
типа, хотя в паскале это не разрешается). В этих массивах будут
храниться элементы множества: оно равно множеству всех val [i]
для тех i, для которых used [i], причем все эти val [i] различны.
По возможности мы будем хранить элемент t на месте h(t),
считая это место "исконным" для элемента t. Однако может случиться
так, что новый элемент, который мы хотим добавить, претендует
на уже занятое место (для которого used истинно). В этом
случае мы отыщем ближайшее справа свободное место и запишем элемент
туда. ("Справа" значит "в сторону увеличения индексов";
дойдя до края, мы перескакиваем в начало.) По предположению,
число элементов всегда меньше n, так что пустые места гарантированно
будут.
Формально говоря, в любой момент должно соблюдаться такое
требование: для любого элемента множества участок справа от его
исконного места до его фактического места полностью заполнен.
Благодаря этому проверка принадлежности заданного элемента
t осуществляется легко: встав на h(t), двигаемся направо, пока
не дойдем до пустого места или до элемента t. В первом случае
элемент t отсутствует в множестве, во втором присутствует. Если
элемент отсутствует, то его можно добавить на найденное пустое
место. Если присутствует, то можно его удалить (положив used =
false).
11.1.1. В предыдущем абзаце есть ошибка. Найдите ее и
исправьте.
Решение. Дело в том, что при удалении требуемое свойство
"отсутствия пустот" может нарушиться. Поэтому будем делать так.
Создав дыру, будем двигаться направо, пока не натолкнемся на еще
одно пустое место (тогда на этом можно успокоиться) или на элемент,
стоящий не на исконном месте. Во втором случае посмотрим,
не нужно ли этот элемент поставить на место дыры. Если нет, то
продолжаем поиск, если да, то затыкаем им старую дыру. При этом
образуется новая дыра, с которой делаем все то же самое.
11.1.2. Написать программы проверки принадлежности, добавления
и удаления.
Решение.
function принадлежит (t: T): boolean;
| var i: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| belong := used [i] and (val [i] = t);
end;
procedure добавить (t: T);
| var i: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| if not used [i] then begin
| | used [i] := true;
| | val [i] := t;
| end;
end;
procedure исключить (t: T);
| var i, gap: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| if used [i] and (val [i] = t) then begin
| | used [i] := false;
| | gap := i;
| | i := (i + 1) mod n;
| | while used [i] do begin
| | | if i = h (val[i]) then begin
| | | | i := (i + 1) mod n;
| | | end else if dist(h(val[i]),i) " dist(gap,i) then begin
| | | | i := (i + 1) mod n;
| | | end else begin
| | | | used [gap] := true;
| | | | val [gap] := val [i];
| | | | used [i] := false;
| | | | gap := i;
| | | | i := i + 1;
| | | end;
| | end;
| end;
end;
Здесь dist (a, b) - измеренное по часовой стрелке (слева
направо) расстояние от a до b, т.е.
dist (a,b) = (b - a + n) mod n.
(Мы прибавили n, так как функция mod правильно работает только
при положительном делимом.)
11.1.3. Существует много вариантов хеширования. Один из них
таков: обнаружив, что исконное место (обозначим его i) занято,
будем искать свободное не среди i+1, i+2,..., а среди r(i),
r(r(i)), r(r(r(i))),..., где r - некоторое отображение 0..n-1 в
себя. Какие при этом будут трудности?
Ответ. (1) Не гарантируется, что если пустые места есть, то
мы их найдем. (2) При удалении неясно, как заполнять дыры. (На
практике во многих случаях удаление не нужно, так что такой способ
также применяется. Считается, что удачный подбор r может
предотвратить образование "скоплений" занятых ячеек.)
11.1.4. Пусть для хранения множества всех правильных
русских слов в программе орфографии используется хеширование.
Что нужно добавить, чтобы к тому же уметь находить английский
перевод любого правильного слова?
Решение. Помимо массива val, элементы которого являются
русскими словами, нужен параллельный массив их английских переводов.
11.2. Хеширование со списками
На хеш-функцию с m значениями можно смотреть как на способ
свести вопрос о хранении одного большого множества к вопросу о
хранении нескольких меньшим. Именно, если у нас есть хеш-функция
с m значениями, то любое множество разбивается на m подмножеств
(возможно, пустых), соответствующих возможных значениям
хэш-функции. Вопрос о проверке принадлежности, добавлении или
удалении для большого множества сводится к такому же вопросу для
одного из меньших (чтобы узнать, для какого, надо посмотреть на
значение хеш-функции).
В принципе, эти меньшие множества могут храниться любым
способом (раз они малы, это не очень важно), но удобно их хранить
с помощью ссылок, поскольку нам известен их суммарный размер
(равный числу элементов хешируемого множества). Следующая
задача предлагает реализовать этот план.
11.2.1. Пусть хеш-функция принимает значения 1..k. Для каждого
значения хеш-функции рассмотрим список всех элементов множества
с данным значением хеш-функции. Будем хранить эти k списков
с помощью переменныхтак же, как мы это делали для k стеков ограниченной суммарной
длины. Напишите соответствующие программы. (Теперь с удалением
будет меньше проблем.)
Решение. Перед началом работы надо положить Вершина[i]=0
для всех i=1..k, и связать все места в список свободного
пространства, положив ПервСвоб=1 и Следующий[i]=i+1 для
i=1..n-1, а также Следующий[n]=0.
function принадлежит (t: T): boolean;
| var i: integer;
begin
| | i := Вершина[h(t)];
| i := Вершина[h(t)];
| {осталось искать в списке, начиная с i}
| while (i "" 0) and (Содержание[i] "" t) do begin
| | i := Следующий[i];
| end; {(i=0) or (Содержание [i] = t)}
| belong := Содержание[i]=t;
end;
procedure добавить (t: T);
| var i: integer;
begin
| if not принадлежит(t) then begin
| | i := ПервСвоб;
| | {ПервСвоб "" 0 - считаем, что не переполняется}
| | ПервСвоб := Следующий[ПервСвоб]
| | Содержание[i]:=t;
| | Следующий[i]:=Вершина[h(t)];
| | Вершина[h(t)]:=i;
| end;
end;
procedure исключить (t: T);
| var i, pred: integer;
begin
| i := Вершина[h(t)]; pred := 0;
| {осталось искать в списке, начиная с i; pred -
| предыдущий. если он есть, и 0, если нет}
| while (i "" 0) and (Содержание[i] "" t) do begin
| | pred := i; i := Следующий[i];
| end; {(i=0) or (Содержание [i] = t)}
| if Содержание[i]=t then begin
| | {элемент есть, надо удалить}
| | if pred = 0 then begin
| | | {элемент оказался первым в списке}
| | | Вершина[h(t)] := Следующий[i];
| | end else begin
| | | Следующий[pred] := Следующий[i]
| | end;
| | {осталось вернуть i в список свободных}
| | Следующий[i] := ПервСвоб;
| | ПервСвоб:=i;
| end;
end;
11.2.2. (Для знакомых с теорией вероятностей.) Пусть
хеш-функция с m значениями используется для хранения множества,
в котором в данный момент n элементов. Доказать, что математическое
ожидание числа действий в предыдущей задаче не превосходит
С*(1+n/m), если добавляемый (удаляемый, искомый) элемент t
выбран случайно, причем все значения h(t) имеют равные вероятности
(равные 1/m).
Решение. Если l(i) - длина списка, соответствующего
хеш-значению i, то число операцией не превосходит C*(1+l(h(i)));
усредняя, получаем искомый ответ, так как сумма всех l(i) равна
n.
Эта оценка основана на предположении о равных вероятностях.
Однако в конкретной ситуации всё может быть совсем не так, и
значения хеш-функции могут "скучиваться": для каждой конкретной
хеш-функции есть "неудачные" ситуации, когда число действий оказывается
большим. Приём, называемый "универсальным хешированием",
позволяет обойти эту проблему. Идея состоит в том, что берётся
семейство хеш-функций, причем любая ситуация оказывается
неудачной лишь для небольшой части этого семества.
Пусть H - семейство функций, каждая из которых отображает
множество T в множество из n элементов (например, 0..n-1). Говорят,
что H - универсальное семейство хеш-функций, если для любых
двух различных значений s и t из множества T вероятность события
"h(s)=h(t)" для случайной функции h из семейства H равна 1/n.
(Другими словами, те функции из H, для которых h(s)=h(t), составляют
1/n-ую часть всех функций в H.)
Замечание. Более сильное требование к семейству H могло бы
состоять в том, чтобы для любых двух различных элементов s и t
множества T значения h(s) и h(t) случайной функции h являются
независимыми случайными величинами, равномерно распределенными
на 0..n-1.
11.2.3. Пусть t[1]..t[u] - произвольная последовательность
различных элементов множества T. Рассмотрим количество действий,
происходящих при помещении элементов t[1]..t[u] в множество, хешируемое
с помощью функции h из универсального семейства H. Доказать,
что среднее количество действий (усреднение - по всем h
из H) не превосходит C*u*(1+u/n).
Решение. Обозначим через m[i] количество элементов последовательности,
для которых хеш-функция равна i. (Числа
m[0]..m[n-1] зависят, конечно, от выбора хеш-функции.) Количество
действий, которое мы хотим оценить, с точностью до постоянного
множителя равно сумме квадратов чисел m[0]..m[n-1]. (Если
k чисел попадают в одну хеш-ячейку, то для этого требуется примерно
1+2+...+k действий.) Эту же сумму квадратов можно записать
как число пар "p,q", для которых h[t[p]]=h[t[q]]. Последнее равенство,
если его рассматривать как событие при фиксированных p
и q, имеет вероятность 1/n при p""q, поэтому среднее значение
соответствующего члена суммы равно 1/n, а для всей суммы получаем
оценку порядка u*u/n, а точнее u*u/n + u, если учесть члены с
p=q.
Оценка этой задачи показывает, что в на каждый добавляемый
элемент приходится в среднем C*(1+u/n) операций. В этой оценке
дробь u/n имеет смысл "коэффициента заполнения" хеш-таблицы.
11.2.4. Доказать аналогичное утверждение для произвольной
последовательности операций добавления, поиска и удаления (а не
только для добавления, как в предыдущей задаче).
Указание. Будем представлять себе, что в ходе поиска, добавления
и удаления элемент проталкивается по списку своих коллег
с тем же хеш-значением, пока не найдет своего двойника или
не дойдет до конца списка. Будем называть i-j-столкновением
столкновение t[i] с t[j]. Общее число действий примерно равно
числу всех столкновений плюс число элементов. При t[i]""t[j] вероятность
i-j-столкновения равна 1/n. Осталось проследить за
столкновениями между равными элементами. Фиксируем некоторое
значение x из множества T и посмотрим на связанные с ним операции.
Они идут по циклу: добавление - проверки - удаление - добавление
- проверки - удаление - ... Столкновения между ними
происходят между добавляемым элементом и следующими за ним проверками
(до удаления включительно), поэтому общее их число не
превосходит числа элементов, равных x.
Теперь приведем примеры универсальных семейств. Очевидно,
для любых конечных множеств A и B семейство всех функций, отображающих
A в B, является универсальным. Однако этот пример с
практической точки зрения бесполезен: для запоминания случайной
функции из этого семейства нужен массив, число элементов в котором
равно числу элементов в множестве A. (А если мы можем себе
позволить такой массив, то никакого хеширования нам не требуется!)
Более практичные примеры универсальных семейств могут быть
построены с помощью несложных алгебраических конструкций. Через
Z[p] мы обозначаем множество вычетов по простому модулю p, т.е.
{0,1,...,p-1}; арифметические операции в этом множестве выполняются
по модулю p. Универсальное семейство образуют все линейные
функционалы на Z[p] в степени n со значениями в Z[p]. Более подробно,
пусть a[1],...,a[n] - произвольные элементы Z[p];
рассмотрим отображение
h: "x[1]...x[n]" |-" a[1]x{1]+...+a{n]z[n]
Мы получаем семейство из (p в степени n) отображений, параметризованное
наборами a[1]...a[n].
11.2.5. Доказать, что это семейство является универсальным.
Указание. Пусть x и y - различные точки пространства Z[p] в
степени n. Какова вероятность того, что случайный функционал
принимает на них одинаковые значения? Другими словами, какова
вероятность того, что он равен нулю на их разности x-y? Ответ
дается таким утверждением: пусть u - ненулевой вектор; тогда все
значения случайного функционала на нем равновероятны.
В следующей задаче множество B={0,1} рассматривается как
множество вычетов по модулю 2.
11.2.6. Семейство всех линейных отображений из (B в степени
m) в (B в степени n) является универсальным.
Родственные идеи неожиданно оказываются полезными в следующей
ситуации (рассказал Д.Варсонофьев). Пусть мы хотим написать
программу, которая обнаруживала (большинство) опечаток в тексте,
но не хотим хранить список всех правильных словоформ. Предлагается
поступить так: выбрать некоторое N и набор функций
f[1],...,f[k], отображающих русские слова в 1..N. В массиве из N
битов положим все биты равными нулю, кроме тех, которые являются
значением какой-то функции набора на какой-то правильной словоформе.
Теперь приближённый тест на правильность словоформы таков:
проверить, что значения всех функций набора на этой словоформе
попадают на места, занятые единицами.
12.1. Представление множеств с помощью деревьев.
Полное двоичное дерево. T-деревья.
Нарисуем точку. Из нее проведем две стрелки (влево вверх и
вправо вверх) в две другие точки. Из каждой из этих точек проведем
по две стрелки и так далее. Полученную картинку (в n-ом слое
будет (2 в степени (n - 1)) точек) называют полным двоичным деревом.
Нижнюю точку называют корнем. У каждой вершины есть два
сына (две вершины, в которые идут стрелки) - левый и правый. У
всякой вершины, кроме корня, есть единственный отец.
Пусть выбрано некоторое конечное множество вершин полного
двоичного дерева, содержащее вместе с каждой вершиной и всех ее
предков. Пусть на каждой вершине этого множества написано значение
фиксированного типа T (то есть задано отображение множества
вершин в множество значений типа T). То, что получится, будем
называть T-деревом. Множество всех T-деревьев обозначим Tree(T).
Рекурсивное определение. Всякое непустое T-дерево разбивается
на три части: корень (несущий пометку из T), левое и правое
поддеревья (которые могут быть и пустыми). Это разбиение устанавливает
взаимно однозначное соответствие между множеством непустых
T-деревьев и произведением T * Tree (T) * Tree (T). Обозначив
через empty пустое дерево, можно написать
Tree (T) = {empty} + T * Tree (T) * Tree (T).
Поддеревья. Высота.
Фиксируем некоторое T-дерево. Для каждой его вершины x определено
ее левое поддерево (левый сын вершины x и все его потомки),
правое поддерево (правый сын вершины x и все его потомки)
и поддерево с корнем в x (вершина x и все ее потомки). Левое
и правое поддеревья вершины x могут быть пустыми, а поддерево с
корнем в x всегда непусто (содержит по крайней мере x). Высотой
поддерева будем считать максимальную длину цепи y[1]..y[n] его
вершин, в которой y [i+1] - сын y [i] для всех i. (Высота пустого
дерева равна нулю, высота дерева из одного корня - единице.)
Упорядоченные T-деревья.
Пусть на множестве значений типа T фиксирован порядок. Назовем
T-дерево упорядоченным, если выполнено такое свойство: для
любой вершины x все пометки в ее левом поддереве меньше пометки
в x, а все пометки в ее правом поддереве больше пометки в x.
12.1.1. Доказать, что в упорядоченном дереве все пометки
различны.
Указание. Индукция по высоте дерева.
Представление множеств с помощью деревьев.
Каждое дерево будем считать представлением множества всех
пометок на его вершинах. При этом одно и то же множество может
иметь различные представления.
Благодаря упорядоченности каждый элемент легко может "найти
свое место" в дереве: придя в какую-то вершину и сравнив себя с
тем, кто там находится, элемент решает, идти ему налево или направо.
Начав с корня и двигаясь по этому правилу, он либо обнаружит,
что такой элемент уже есть, либо найдет место, в котором он
должен быть. Всюду далее мы предполагаем, что на значениях типа
T задан порядок, и рассматриваем только упорядоченные деревья.
Хранение деревьев в программе.
Можно было бы сопоставить вершины полного двоичного дерева
с числами 1, 2, 3,... (считая, что левый сын (n) = 2n, правый
сын (n) = 2n + 1) и хранить пометки в массиве val [1...]. Однако
этот способ неэкономен, поскольку тратится место на хранение
пустых вакансий в полном двоичном дереве.
Более экономен такой способ. Введем три массива
val: array [1..n] of T;
left, right: array [1..n] of 0..n;
(n - максимальное возможное число вершин дерева) и переменную
root: 0..n. Каждая вершина хранимого T-дерева будет иметь номер
- число от 1 до n. Разные вершины будут иметь разные номера. Пометка
в вершине с номером x равна val [x]. Корень имеет номер
root. Если вершина с номером i имеет сыновей, то их номера равны
left [i] и right [i]. Отсутствующим сыновьям соответствует число
0. Аналогичным образом значение root = 0 соответствует пустому
дереву.
Для хранения дерева используется лишь часть массива; для
тех i, которые свободны - т.е. не являются номерами вершин -
значения val [i] безразличны. Нам будет удобно, чтобы все свободные
числа были "связаны в список": первое хранится в специальное
переменной free: 0..n, а следующее за i свободное число
хранится в left [i], так что свободны числа
free, left [free], left [left[free]],...
Для последнего свободного числа i значение left [i] = 0. Равенство
free = 0 означает, что свободных чисел больше нет. (Замечание.
Мы использовали для связывания свободных вершин массив
left, но, конечно, с тем же успехом можно было использовать массив
right.)
Вместо значения 0 (обозначающего отсутствие вершины) можно
было бы воспользоваться любым другим числом вне 1..n. Чтобы подчеркнуть
это, будем вместо 0 использовать константу null = 0.
12.1.2. Составить программу, определяющую, содержится ли
элемент t: T в упорядоченном дереве (хранимом так, как только
что описано).
Решение.
if root = null then begin
| ..не принадлежит
end else begin
| x := root;
| {инвариант: остается проверить наличие t в непустом подде-
| реве с корнем x}
| while ((t " val [x]) and (left [x] "" null)) or
| | ((t " val [x]) and (right [x] "" null)) do begin
| | if t " val [x] then begin {left [x] "" null}
| | | x := left [x];
| | end else begin {t " val [x], right [x] "" null}
| | | x := right [x];
| | end;
| end;
| {либо t = val [x], либо t отсутствует в дереве}
| ..ответ = (t = val [x])
end;
12.1.3. Упростить решение, используя следующий трюк. Расширим
область определения массива val, добавив ячейку с номером
null и положим val [null] = t.
Решение.
val [null] := t;
x := root;
while t "" val [x] do begin
| if t " val [x] then begin
| | x := left [x];
| end else begin
| | x := right [x];
| end;
end;
..ответ: (x "" null).
12.1.4. Составить программу добавления элемента t в множество,
представленное упорядоченным деревом (если элемент t уже
есть, ничего делать не надо).
Решение. Определим процедуру get_free (var i: integer), дающую
свободное (не являющееся номером) число i и соответствующим
образом корректирующую список свободных чисел.
procedure get_free (var i: integer);
begin
| {free "" null}
| i := free;
| free := left [free];
end;
С ее использованием программа приобретает вид:
if root = null then begin
| get_free (root);
| left [root] := null; right [root] := null;
| val [root] := t;
end else begin
| x := root;
| {инвариант: осталось добавить t к непустому поддереву с
| корнем в x}
| while ((t " val [x]) and (left [x] "" null)) or
| | ((t " val [x]) and (right [x] "" null)) do begin
| | if t " val [x] then begin
| | | x := left [x];
| | end else begin {t " val [x]}
| | | x := right [x];
| | end;
| end;
| if t "" val [x] then begin {t нет в дереве}
| | get_free (i);
| | left [i] := null; right [i] := null;
| | val [i] := t;
| | if t " val [x] then begin
| | | left [x] := i;
| | end else begin {t " val [x]}
| | | right [x] := i;
| | end;
| end;
end;
12.1.5. Составить программу удаления элемента t из множества,
представленного упорядоченным деревом (если его там нет,
ничего делать не надо).
Решение.
if root = null then begin
| {дерево пусто, ничего делать не надо}
end else begin
| x := root;
| {осталось удалить t из поддерева с корнем в x; поскольку
| это может потребовать изменений в отце x, введем
| переменные father: 1..n и direction: (l, r);
| поддерживаем такой инвариант: если x не корень, то father
| - его отец, а direction равно l или r в зависимости от
| того, левым или правым сыном является x}
| while ((t " val [x]) and (left [x] "" null)) or
| | ((t " val [x]) and (right [x] "" null)) do begin
| | if t " val [x] then begin
| | | father := x; direction := l;
| | | x := left [x];
| | end else begin {t " val [x]}
| | | father := x; direction := r;
| | | x := right [x];
| | end;
| end;
| {t = val [x] или t нет в дереве}
| if t = val [x] then begin
| | ..удаление вершины x с отцом father и направлением
| | direction
| end;
end;
Удаление вершины x происходит по-разному в разных случаях. При
этом используется процедура
procedure make_free (i: in
...Закладка в соц.сетях
