Если удаляемый узел имеет два дочерних, то не обязательно один из них займет
место удаленного узла. Если потомки узла также имеют по два дочерних узла, то
все потомки не смогут занять место удаленного узла. Удаленный узел имеет одного
лишнего потомка, и дочерний узел, который вы хотели бы поместить на его место,
также имеет двух потомков, так что на узел пришлось бы три потомка.
Чтобы решить эту проблему, удаленный узел заменяется самым правым узлом из
левой ветви. Другими словами, нужно сдвинуться на один шаг вниз по левой ветви,
выходившей из удаленного узла. Затем нужно двигаться по правым ветвям вниз до
тех пор, пока не найдется узел, который не имеет правой ветви. Это самый правый
узел на ветви слева от удаляемого узла. В дереве, показанном слева на рис. 6.18,
узел 3 является самым правым узлом в левой от узла 4 ветви. Можно заменить узел
4 листом 3, сохранив при этом порядок дерева.
@Рис. 6.18. Удаление узла, который имеет два дочерних
=======136
@Рис. 6.19. Удаление узла, если заменяющий его узел имеет потомка
Остается последний вариант — когда заменяющий узел имеет левого потомка.
В этом случае, вы можете переместить этого потомка на место, освободившееся
в результате перемещения замещающего узла, и дерево снова будет расположено
в нужном порядке. Уже известно, что самый правый узел не имеет правого потомка,
иначе он не был бы таковым. Это означает, что не нужно беспокоиться, не имеет
ли замещающий узел двух потомков.
Эта сложная ситуация показана на рис. 6.19. В этом примере удаляется узел
8. Самый правый элемент в его левой ветви — это узел 7, который имеет потомка
— узел 5. Чтобы сохранить порядок дерева после удаления узла 8, заменим узел
8 узлом 7, а узел 7 — узлом 5. Заметьте, что узел 7 получает новых потомков,
а узел 5 сохраняет своих.
Следующий код удаляет узел из упорядоченного двоичного дерева:
Private Sub DeleteItem(node As SortNode, target_value As Integer)
Dim target As SortNode
Dim child As SortNode
' Если узел не найден, вывести сообщение.
If node Is Nothing Then
Beep
MsgBox "Item " & Format$(target_value) & _
" не найден в дереве."
Exit Sub
End If
If target_value < node.Value Then
' Продолжить для левого поддерева.
Set child = node.LeftChild
DeleteItem child, target_value
Set node.LeftChild = child
ElseIf target_value > node.Value Then
' Продолжить для правого поддерева.
Set child = node.RightChild
DeleteItem child, target_value
Set node.RightChild = child
Else
' Искомый узел найден.
Set target = node
If target.LeftChild Is Nothing Then
' Заменить искомый узел его правым потомком.
Set node = node.RightChild
ElseIf target.RightChild Is Nothing Then
' Заменить искомый узел его левым потомком.
Set node = node.LeftChild
Else
' Вызов подпрограмы ReplaceRightmost для замены
' искомого узла самым правым узлом
' в его левой ветви.
Set child = node.LeftChild
ReplaceRightmost node, child
Set node.LeftChild = child
End If
End If
End Sub
Private Sub ReplaceRightmost(target As SortNode, repl As SortNode)
Dim old_repl As SortNode
Dim child As SortNode
If Not (repl.RightChild Is Nothing) Then
' Продолжить движение вправо и вниз.
Set child = repl.RightChild
ReplaceRightmost target, child
Set repl.RightChild = child
Else
' Достигли дна.
' Запомнить заменяющий узел repl.
Set old_repl = repl
' Заменить узел repl его левым потомком.
Set repl = repl.LeftChild
' Заменить искомый узел target with repl.
Set old_repl.LeftChild = target.LeftChild
Set old_repl.RightChild = target.RightChild
Set target = old_repl
End If
End Sub
======137-138
Алгоритм использует в двух местах прием передачи параметров в рекурсивные
подпрограммы по ссылке. Во‑первых, подпрограмма DeleteItem
использует этот прием для того, чтобы родитель искомого узла указывал на заменяющий
узел. Следующие операторы показывают, как вызывается подпрограмма
DeleteItem:
Set child = node.LeftChild
DeleteItem child, target_value
Set node.LeftChild = child
Когда процедура обнаруживает искомый узел (узел 8 на рис. 6.19), она получает
в качестве параметра узла указатель родителя на искомый узел. Устанавливая параметр
на замещающий узел (узел 7), подпрограмма DeleteItem
задает дочерний узел для родителя так, чтобы он указывал на новый узел.
Следующие операторы показывают, как процедура ReplaceRightMost
рекурсивно вызывает себя:
Set child = repl.RightChild
ReplaceRightmost target, child
Set repl.RightChild = child
Когда процедура находит самый правый узел в левой от удаляемого узла ветви
(узел 7), в параметре repl находится указатель родителя
на самый правый узел. Когда процедура устанавливает значение
repl равным repl.LeftChild,
она автоматически соединяет родителя самого правого узла с левым дочерним узлом
самого правого узла (узлом 5).
Программа TreeSort на диске с примерами использует
эти процедуры для работы с упорядоченными двоичными деревьями. Введите целое
число, и нажмите на кнопку Add, чтобы добавить элемент к дереву. Введите целое
число, и нажмите на кнопку Remove, чтобы удалить этот элемент из дерева. После
удаления узла, дерево автоматически переупорядочивается для сохранения порядка
«меньше».
Обход упорядоченных деревьев
Полезное свойство упорядоченных деревьев состоит в том, что их порядок совпадает
с порядком симметричного обхода. Например, при симметричном обходе дерева, показанного
на рис. 6.20, обращение к узлам происходит в порядке 2-4-5-6-7-8-9.
@Рис. 6.20. Симметричный обход упорядоченного дерева: 2, 4, 5, 6, 7, 8, 9
=========139
Это свойство симметричного обхода упорядоченных деревьев приводит к простому
алгоритму сортировки:
1. Добавить элемент к упорядоченному дереву.
2. Вывести элементы, используя симметричный обход.
Этот алгоритм обычно работает достаточно хорошо. Тем не менее, если добавлять
элементы к дереву в определенном порядке, то дерево может стать высоким и тонким.
На рис. 6.21 показано упорядоченное дерево, которое получается при добавлении
к нему элементов в порядке 1, 6, 5, 2, 3, 4. Другие последовательности также
могут приводить к появлению высоких и тонких деревьев.
Чем выше становится упорядоченное дерево, тем больше времени требуется для
добавления новых элементов в нижнюю часть дерева. В наихудшем случае, после
добавления N элементов, дерево будет иметь высоту порядка O(N). Полное время
вставки всех элементов в дерево будет при этом порядка O(N2). Поскольку для
обхода дерева требуется время порядка O(N), полное время сортировки чисел с
использованием дерева будет равно O(N2)+O(N)=O(N2).
Если дерево остается достаточно коротким, оно имеет высоту порядка O(log(N)).
В этом случае для вставки элемента в дерево потребуется всего порядка O(log(N))
шагов. Вставка всех N элементов в дерево потребует порядка O(N * log(N)) шагов.
Тогда сортировка элементов при помощи дерева потребует времени порядка O(N *
log(N)) + O(N) = O(N * log(N)).
Время выполнения порядка O(N * log(N)) намного меньше, чем O(N2). Например,
построение высокого и тонкого дерева, содержащего 1000 элементов, потребует
выполнения около миллиона шагов. Построение короткого дерева с высотой порядка
O(log(N)) займет всего около 10.000 шагов.
Если элементы первоначально расположены в случайном порядке, форма дерева
будет представлять что‑то среднее между этими двумя крайними случаями. Хотя
его высота может оказаться несколько больше, чем log(N), оно, скорее всего,
не будет слишком тонким и высоким, поэтому алгоритм сортировки будет выполняться
достаточно быстро.
@Рис. 6.21. Дерево, полученное добавлением элементов в порядке 1, 6, 5, 2,
3, 4
==========140
В 7 главе описываются способы балансировки деревьев, для того, чтобы они
не становились слишком высокими и тонкими, независимо от того, в каком порядке
в них добавляются новые элементы. Тем не менее, эти методы достаточно сложны,
и их не имеет смысла применять в алгоритме сортировки при помощи дерева. Многие
из алгоритмов сортировки, описанных в 9 главе, более просты в реализации и обеспечивают
при этом лучшую производительность.
Деревья со ссылками
Во 2 главе показано, как добавление ссылок к связным спискам позволяет упростить
вывод элементов в разном порядке. Вы можете использовать тот же подход для упрощения
обращения к узлам дерева в различном порядке. Например, помещая ссылки в листья
двоичного дерева, вы можете облегчить выполнение симметричного и обратного обходов.
Для упорядоченного дерева, это обход в прямом и обратном порядке сортировки.
Для создания ссылок, указатели на предыдущий и следующий узлы в порядке симметричного
обхода помещаются в неиспользуемых указателях на дочерние узлы. Если не используется
указатель на левого потомка, то ссылка записывается на его место, указывая на
предыдущий узел при симметричном обходе. Если не используется указатель на правого
потомка, то ссылка записывается на его место, указывая на следующий узел при
симметричном обходе. Поскольку ссылки симметричны, и ссылки левых потомков указывают
на предыдущие, а правых — на следующие узлы, этот тип деревьев называется деревом
с симметричными ссылками (symmetrically threaded tree). На рис. 6.22 показано
дерево с симметричными ссылками, которые обозначены пунктирными линиями.
Поскольку ссылки занимают место указателей на дочерние узлы дерева, нужно
как‑то различать ссылки и обычные указатели на потомков. Проще всего добавить
к узлам новые переменные HasLeftChild и
HasRightChild типа Boolean,
которые будут равны True, если узел имеет левого или
правого потомка соответственно.
Чтобы использовать ссылки для поиска предыдущего узла, нужно проверить указатель
на левого потомка узла. Если этот указатель является ссылкой, то ссылка указывает
на предыдущий узел. Если значение указателя равно Nothing,
значит это первый узел дерева, и поэтому он не имеет предшественников. В противном
случае, перейдем по указателю к левому дочернему узлу. Затем проследуем по указателям
на правый дочерний узел потомков, до тех пор, пока не достигнем узла, в котором
на месте указателя на правого потомка находится ссылка. Этот узел (а не тот,
на который указывает ссылка) является предшественником исходного узла. Этот
узел является самым правым в левой от исходного узла ветви дерева. Следующий
код демонстрирует поиск предшественника:
@Рис. 6.22. Дерево с симметричными ссылками
==========141
Private Function Predecessor(node As ThreadedNode) As ThreadedNode Dim child
As ThreadedNode
If node.LeftChild Is Nothing Then
' Это первый узел в порядке симметричного обхода.
Set Predecessor = Nothing
Else If node.HasLeftChild Then
' Это указатель на узел.
' Найти самый правый узел в левой ветви.
Set child = node.LeftChild
Do While child.HasRightChild
Set child = child.RightChild
Loop
Set Predecessor = child
Else
' Ссылка указывает на предшественника.
Set Predecessor = node.LeftChild
End If
End Function
Аналогично выполняется поиск следующего узла. Если указатель на правый дочерний
узел является ссылкой, то она указывает на следующий узел. Если указатель имеет
значение Nothing, то это последний узел дерева, поэтому
он не имеет последователя. В противном случае, переходим по указателю к правому
потомку узла. Затем перемещаемся по указателям дочерних узлов до тех, пор, пока
очередной указатель на левый дочерний узел не окажется ссылкой. Тогда найденный
узел будет следующим за исходным. Это будет самый левый узел в правой от исходного
узла ветви дерева.
Удобно также ввести функции для нахождения первого и последнего узлов дерева.
Чтобы найти первый узел, просто проследуем по указателям на левого потомка вниз
от корня до тех пор, пока не достигнем узла, значение указателя на левого потомка
для которого равно Nothing. Чтобы найти последний
узел, проследуем по указателям на правого потомка вниз от корня до тех пор,
пока не достигнем узла, значение указателя на правого потомка для которого равно
Nothing.
Private Function FirstNode() As ThreadedNode
Dim node As ThreadedNode
Set node = Root
Do While Not (node.LeftChild Is Nothing)
Set node = node.LeftChild
Loop
Set PirstNode = node
End Function
Private Function LastNode() As ThreadedNode
Dim node As ThreadedNode
Set node = Root
Do While Not (node.RightChild Is Nothing)
Set node = node.RightChild
Loop
Set FirstNode = node
End Function
=========142
При помощи этих функций вы можете легко написать процедуры, которые выводят
узлы дерева в прямом или обратном порядке:
Private Sub Inorder()
Dim node As ThreadedNode
' Найти первый узел.
Set node = FirstNode()
' Вывод списка.
Do While Not (node Is Nothing)
Print node.Value
Set node = Successor(node)
Loop
End Sub
Private Sub PrintReverseInorder()
Dim node As ThreadedNode
' Найти последний узел
Set node = LastNode
' Вывод списка.
Do While Not (node Is Nothing)
Print node. Value
Set node = Predecessor(node)
Loop
End Sub
Процедура вывода узлов в порядке симметричного обхода, приведенная ранее
в этой главе, использует рекурсию. Для устранения рекурсии вы можете использовать
эти новые процедуры, которые не используют ни рекурсию, ни системный стек.
Каждый указатель на дочерние узлы в дереве содержит или указатель на потомка,
или ссылку на предшественника или последователя. Так как каждый узел имеет два
указателя на дочерние узлы, то, если дерево имеет N узлов, то оно будет содержать
2 * N ссылок и указателей. Эти алгоритмы обхода обращаются ко всем ссылкам и
указателям дерева один раз, поэтому они потребуют выполнения O(2 * N) = O(N)
шагов.
