Дерево поиска, наивная реализация — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
м (rollbackEdits.php mass rollback)
 
(не показано 198 промежуточных версий 11 участников)
Строка 2: Строка 2:
 
Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
 
Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
 
== Операции в бинарном дереве поиска ==
 
== Операции в бинарном дереве поиска ==
 +
Для представления бинарного дерева поиска в памяти будем использовать следующую структуру:
 +
'''struct''' Node:
 +
  '''T''' key                    <font color="green">// ключ узла</font>
 +
  '''Node''' left                <font color="green">// указатель на левого потомка</font>
 +
  '''Node''' right              <font color="green">// указатель на правого потомка</font>
 +
  '''Node''' parent              <font color="green">// указатель на предка</font>
 +
 
=== Обход дерева поиска ===
 
=== Обход дерева поиска ===
 
Есть три операции обхода узлов дерева, отличающиеся порядком обхода узлов:
 
Есть три операции обхода узлов дерева, отличающиеся порядком обхода узлов:
* <tex>\mathrm{inorderTraversal}</tex> {{---}} обход узлов в отсортированном порядке
+
* <tex>\mathrm{inorderTraversal}</tex> {{---}} обход узлов в отсортированном порядке,
* <tex>\mathrm{preorderTraversal}</tex> {{---}} обход узлов в порядке: вершина, левое поддерево, правое поддерево
+
* <tex>\mathrm{preorderTraversal}</tex> {{---}} обход узлов в порядке: вершина, левое поддерево, правое поддерево,
* <tex>\mathrm{postorderTraversal}</tex> {{---}} обход узлов в порядке: левое поддерево, правое поддерево, вершина
+
* <tex>\mathrm{postorderTraversal}</tex> {{---}} обход узлов в порядке: левое поддерево, правое поддерево, вершина.
  inorderTraversal('''Node''' x)
+
  '''func''' inorderTraversal(x : '''Node'''):
     '''if''' x != null
+
     '''if''' x != ''null''
 
       inorderTraversal(x.left)
 
       inorderTraversal(x.left)
 
       '''print''' x.key
 
       '''print''' x.key
 
       inorderTraversal(x.right)
 
       inorderTraversal(x.right)
Корректность данного алгоритма следует из свойств бинарного дерева поиска.  
+
При выполнении данного обхода вершины будут выведены в следующем порядке: ''1 3 4 6 7 8 10 13 14''.
  preorderTraversal('''Node''' x)
+
 
     '''if''' x != null
+
  '''func''' preorderTraversal(x : '''Node''')
 +
     '''if''' x != ''null''
 
       '''print''' x.key
 
       '''print''' x.key
 
       preorderTraversal(x.left)
 
       preorderTraversal(x.left)
 
       preorderTraversal(x.right)
 
       preorderTraversal(x.right)
 +
При выполнении данного обхода вершины будут выведены в следующем порядке: ''8 3 1 6 4 7 10 14 13''.
  
  postfixTraversal('''Node''' x)
+
  '''func''' postorderTraversal(x : '''Node''')
     '''if''' x != null
+
     '''if''' x != ''null''
 
       postorderTraversal(x.left)
 
       postorderTraversal(x.left)
 
       postorderTraversal(x.right)
 
       postorderTraversal(x.right)
 
       '''print''' x.key
 
       '''print''' x.key
Данные алгоритмы выполняют обход за время <tex>O(n)</tex>, поскольку процедура вызывается ровно два раза для каждого узла дерева.  
+
При выполнении данного обхода вершины будут выведены в следующем порядке: ''1 4 7 6 3 13 14 10 8''.
 +
 
 +
Данные алгоритмы выполняют обход за время <tex>O(n)</tex>, поскольку процедура вызывается ровно два раза для каждого узла дерева.
 +
 
 
=== Поиск элемента ===
 
=== Поиск элемента ===
[[Файл:Bst search.png|thumb|318px|Поиск элемента 4]]
+
[[Файл:Bst search.png|frame|right|318px|Поиск элемента 4]]
Для поиска элемента в бинарном дереве поиска можно воспользоваться следующей процедурой, которая принимает в качестве параметров корень дерева и искомый ключ. Для каждого узла функция сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае функция вызывается рекурсивно для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
+
Для поиска элемента в бинарном дереве поиска можно воспользоваться следующей функцией, которая принимает в качестве параметров корень дерева и искомый ключ. Для каждого узла функция сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае функция вызывается рекурсивно для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
  '''Node''' search('''Node''' x, '''key''' k)
+
<div style="width: 65%">
     '''if''' x == null '''or''' k == x.key
+
  '''Node''' search(x : '''Node''', k : '''T'''):
 +
     '''if''' x == ''null'' '''or''' k == x.key
 
       '''return''' x
 
       '''return''' x
 
     '''if''' k < x.key
 
     '''if''' k < x.key
Строка 35: Строка 48:
 
     '''else'''
 
     '''else'''
 
       '''return''' search(x.right, k)
 
       '''return''' search(x.right, k)
 +
</div>
  
 
=== Поиск минимума и максимума ===
 
=== Поиск минимума и максимума ===
 
Чтобы найти минимальный элемент в бинарном дереве поиска, необходимо просто следовать указателям <tex>left</tex> от корня дерева, пока не встретится значение <tex>null</tex>. Если у вершины есть левое поддерево, то по свойству бинарного дерева поиска в нем хранятся все элементы с меньшим ключом. Если его нет, значит эта вершина и есть минимальная. Аналогично ищется и максимальный элемент. Для этого нужно следовать правым указателям.
 
Чтобы найти минимальный элемент в бинарном дереве поиска, необходимо просто следовать указателям <tex>left</tex> от корня дерева, пока не встретится значение <tex>null</tex>. Если у вершины есть левое поддерево, то по свойству бинарного дерева поиска в нем хранятся все элементы с меньшим ключом. Если его нет, значит эта вершина и есть минимальная. Аналогично ищется и максимальный элемент. Для этого нужно следовать правым указателям.
  '''Node''' minimum('''Node''' x)
+
  '''Node''' minimum(x : '''Node'''):
   '''if''' x.left == null
+
   '''if''' x.left == ''null''
 
       '''return''' x
 
       '''return''' x
 
   '''return''' minimum(x.left)
 
   '''return''' minimum(x.left)
  
  '''Node''' maximum('''Node''' x)
+
  '''Node''' maximum(x : '''Node'''):
   '''if''' x.right == null
+
   '''if''' x.right == ''null''
 
       '''return''' x
 
       '''return''' x
 
   '''return''' maximum(x.right)
 
   '''return''' maximum(x.right)
Строка 51: Строка 65:
 
=== Поиск следующего и предыдущего элемента ===
 
=== Поиск следующего и предыдущего элемента ===
 
====Реализация с использованием информации о родителе====
 
====Реализация с использованием информации о родителе====
Если у узла есть правое поддерево, то следующий за ним элемент будет минимальным элементом в этом поддереве. Если у него нет правого поддерева, то нужно следовать вверх, пока не встретим узел, который является левым дочерним узлом своего родителя. Поиск предыдущего выполнятся аналогично. Если у узла есть левое поддерево, то следующий за ним элемент будет максимальным элементом в этом поддереве. Если у него нет левого поддерева, то нужно следовать вверх, пока не встретим узел, который является правым дочерним узлом своего родителя.  
+
Если у узла есть правое поддерево, то следующий за ним элемент будет минимальным элементом в этом поддереве. Если у него нет правого поддерева, то нужно следовать вверх, пока не встретим узел, который является левым дочерним узлом своего родителя. Поиск предыдущего выполнятся аналогично. Если у узла есть левое поддерево, то предыдущий ему элемент будет максимальным элементом в этом поддереве. Если у него нет левого поддерева, то нужно следовать вверх, пока не встретим узел, который является правым дочерним узлом своего родителя.  
  '''Node''' next('''Node''' x)
+
  '''Node''' next(x : '''Node'''):
     '''if''' x.right != null
+
     '''if''' x.right != ''null''
 
       '''return''' minimum(x.right)
 
       '''return''' minimum(x.right)
 
     y = x.parent
 
     y = x.parent
     '''while''' y != null '''and''' x == y.right
+
     '''while''' y != ''null'' '''and''' x == y.right
 
       x = y
 
       x = y
 
       y = y.parent
 
       y = y.parent
 
     '''return''' y
 
     '''return''' y
  
  '''Node''' prev('''Node''' x)
+
  '''Node''' prev(x : '''Node'''):
     '''if''' x.left != null
+
     '''if''' x.left != ''null''
 
       '''return''' maximum(x.left)
 
       '''return''' maximum(x.left)
 
     y = x.parent
 
     y = x.parent
     '''while''' y != null '''and''' x == y.left
+
     '''while''' y != ''null'' '''and''' x == y.left
 
       x = y
 
       x = y
 
       y = y.parent
 
       y = y.parent
 
     '''return''' y
 
     '''return''' y
 
Обе операции выполняются за время <tex>O(h)</tex>.
 
Обе операции выполняются за время <tex>O(h)</tex>.
 +
 
====Реализация без использования информации о родителе====
 
====Реализация без использования информации о родителе====
Если у узла есть правое поддерево, то следующий за ним элемент будет минимальным элементом в этом поддереве. Если у него нет правого поддерева, то начнем поиск от корня. Спускаемся вниз по дереву. Если значение узла больше значения в рассматриваемом в данный момент узле, перейдем в правое поддерево, иначе перейдем в левое поддерево. Аналогично выполняется поиск предыдущего элемента. Рекурсивные реализации обеих функций:
+
Рассмотрим поиск следующего элемента для некоторого ключа <tex>x</tex>. Поиск будем начинать с корня дерева, храня текущий узел <tex>current</tex> и узел <tex>successor</tex>, последний посещенный узел, ключ которого больше <tex>x</tex>. <br>
'''Node''' next('''Node''' x, '''Node''' t)        <font color="green">// x - элемент, для которого ищем следующий, t - текущее поддерево</font>
+
Спускаемся вниз по дереву, как в алгоритме поиска узла. Рассмотрим ключ текущего узла <tex>current</tex>. Если <tex>current.key \leqslant x</tex>, значит следующий за <tex>x</tex> узел находится в правом поддереве (в левом поддереве все ключи меньше <tex>current.key</tex>). Если же <tex>x < current.key</tex>, то <tex>x < next(x) \leqslant current.key</tex>, поэтому <tex>current</tex> может быть следующим для ключа <tex>x</tex>, либо следующий узел содержится в левом поддереве <tex>current</tex>. Перейдем к нужному поддереву и повторим те же самые действия.<br>
    '''if''' t != null
+
Аналогично реализуется операция поиска предыдущего элемента.
      '''Node''' successor = next(x, t.left)
+
'''Node''' next(x : '''T'''):
      '''if''' successor == null
+
     '''Node''' current = root, successor = ''null''               <font color="green">// root {{---}} корень дерева</font>
          '''if''' t.key > x.key
+
     '''while''' current != ''null''
            '''return''' t
+
       '''if''' current.key > x
      '''else'''
+
          successor = current
          '''return''' successor
+
           current = current.left
      '''return''' next(x, t.right)
 
     '''return''' null
 
 
 
'''Node''' prev('''Node''' x, '''Node''' t)        <font color="green">// x - элемент, для которого ищем предыдущий, t - текущее поддерево</font>
 
     '''if''' t != null
 
      '''Node''' ancestor = prev(x, t.right)
 
       '''if''' ancestor == null
 
           '''if''' t.key <= x.key
 
            '''return''' t
 
 
       '''else'''
 
       '''else'''
           '''return''' ancestor
+
           current = current.right
      '''return''' prev(x, t.left)
+
     '''return''' successor
     '''return''' null
 
Обе операции выполняются за время <tex>O(h)</tex>.
 
 
=== Вставка ===
 
=== Вставка ===
 
Операция вставки работает аналогично поиску элемента, только при обнаружении у элемента отсутствия ребенка нужно подвесить на него вставляемый элемент.
 
Операция вставки работает аналогично поиску элемента, только при обнаружении у элемента отсутствия ребенка нужно подвесить на него вставляемый элемент.
  insert('''Node''' x, '''Node''' z)            <font color="green">// x - корень поддерева, z - вставляемый элемент</font>
+
====Реализация с использованием информации о родителе====
     '''if''' z.key > x.key
+
  '''func''' insert(x : '''Node''', z : '''Node'''):           <font color="green">// x {{---}} корень поддерева, z {{---}} вставляемый элемент</font>
      '''if''' x.right != null
+
     '''while''' x != ''null''
          insert(x.right, z)
+
      '''if''' z.key > x.key
      '''else'''
+
        '''if''' x.right != ''null''
          z.parent = x;
+
            x = x.right
          x.right = z;
+
        '''else'''
    '''else'''
+
            z.parent = x
      '''if''' x.left != null
+
            x.right = z
          insert(x.left, z)
+
            '''break'''
       '''else'''
+
      '''else if''' z.key < x.key
          z.parent = x;
+
        '''if''' x.left != ''null''
          x.left = z;
+
            x = x.left
 +
        '''else'''
 +
            z.parent = x
 +
            x.left = z
 +
            '''break'''
 +
====Реализация без использования информации о родителе====
 +
'''Node''' insert(x : '''Node''', z : '''T'''):              <font color="green">// x {{---}} корень поддерева, z {{---}} вставляемый ключ</font>
 +
    '''if''' x == ''null''
 +
       '''return''' Node(z)                        <font color="green">// подвесим Node с key = z</font>
 +
    '''else if''' z < x.key
 +
      x.left = insert(x.left, z)
 +
    '''else if''' z > x.key
 +
      x.right = insert(x.right, z)
 +
    '''return''' x
  
Время работы алгоритма {{---}} <tex>O(h)</tex>.
+
Время работы алгоритма для обеих реализаций {{---}} <tex>O(h)</tex>.
  
 
=== Удаление ===
 
=== Удаление ===
 
====Нерекурсивная реализация====
 
====Нерекурсивная реализация====
Для удаления узла из бинарного дерева поиска нужно рассмотреть три возможные ситуации. Если у узла нет дочерних узлов, то у его родителя нужно просто заменить указатель на <tex>null</tex>. Если у узла есть только один дочерний узел, то нужно создать новую связь между родителем удаляемого узла и его дочерним узлом. Наконец, если у узла два дочерних узла, то нужно найти следующий за ним элемент (у этого элемента не будет левого потомка) и переместить его на место удаляемого узла. Время работы алгоритма {{---}} <tex>O(h)</tex>.
+
Для удаления узла из бинарного дерева поиска нужно рассмотреть три возможные ситуации. Если у узла нет дочерних узлов, то у его родителя нужно просто заменить указатель на <tex>null</tex>. Если у узла есть только один дочерний узел, то нужно создать новую связь между родителем удаляемого узла и его дочерним узлом. Наконец, если у узла два дочерних узла, то нужно найти следующий за ним элемент (у этого элемента не будет левого потомка), его правого потомка подвесить на место найденного элемента, а удаляемый узел заменить найденным узлом. Таким образом, свойство бинарного дерева поиска не будет нарушено. Данная реализация удаления не увеличивает высоту дерева. Время работы алгоритма {{---}} <tex>O(h)</tex>.
 
{| border="1" cellpadding="5" cellspacing="0"  
 
{| border="1" cellpadding="5" cellspacing="0"  
 
  !Случай
 
  !Случай
Строка 128: Строка 145:
 
  | [[Файл:Bst_del3.png‎|900px]]
 
  | [[Файл:Bst_del3.png‎|900px]]
 
  |}
 
  |}
  delete('''Node''' root, '''Node''' z)                         <font color="green">// корень поддерева, удаляемый элемент</font>
+
  '''func''' delete(t : '''Node''', v : '''Node'''):                <font color="green">// <tex>t</tex> {{---}} дерево, <tex>v</tex> {{---}} удаляемый элемент</font>
  '''Node''' x, y                                      <font color="green">// x - элемент, который нужно поместить вместо y</font>
+
    p = v.parent                                  <font color="green">// предок удаляемого элемента</font>
  '''if''' z.left != null '''and''' z.right != null           <font color="green">// если z имеет двух детей</font>
+
    '''if''' v.left == ''null'' '''and''' v.right == ''null''         <font color="green">// первый случай: удаляемый элемент - лист</font>
      y = '''next'''(z)                                  <font color="green">// y - элемент, следующий за удаляемым, x - null</font>
+
      '''if''' p.left == v
       x = null
+
        p.left = ''null''
       '''if''' y == y.parent.left
+
      '''if''' p.right == v
        y.parent.left = null
+
        p.right = ''null''
 +
    '''else if''' v.left == ''null'' '''or''' v.right == ''null''    <font color="green">// второй случай: удаляемый элемент имеет одного потомка</font>
 +
        '''if''' v.left == ''null''               
 +
            '''if''' p.left == v
 +
              p.left = v.right
 +
            '''else'''
 +
              p.right = v.right
 +
            v.right.parent = p
 +
        '''else'''
 +
            '''if''' p.left == v
 +
                p.left = v.left
 +
            '''else'''
 +
                p.right = v.left
 +
            v.left.parent = p
 +
    '''else'''                                         <font color="green">// третий случай: удаляемый элемент имеет двух потомков</font>
 +
       successor = next(v, t)                 
 +
      v.key = successor.key
 +
       '''if''' successor.parent.left == successor
 +
        successor.parent.left = successor.right
 +
        '''if''' successor.right != ''null''
 +
          successor.right.parent = successor.parent
 
       '''else'''
 
       '''else'''
        y.parent.right = null
+
        successor.parent.right = successor.right
      z.key = y.key                                <font color="green">// подвешиваем y вместо z</font>
+
        '''if''' successor.right != ''null''
      z.data = y.data
+
          successor.right.parent = successor.parent
  '''else if''' z.left != null '''or''' z.right != null      <font color="green">// eсли z имеет одного ребенка</font>
+
 
      y = z                                        <font color="green">// y - удаляемый элемент</font>
 
      '''if''' y.left != null                           <font color="green">// x - ребенок y</font>
 
        x = y.left           
 
      '''else'''
 
        x = y.right
 
  '''else'''                                            <font color="green">// если z не имеет детей</font>
 
      y = z                                        <font color="green">// y - удаляемый элемент, x - null</font>
 
      x = null
 
  '''if''' x != null                                    <font color="green">// подвешиваем x вместо y</font>
 
      x.parent = y.parent         
 
  '''if''' y.parent == null
 
      root = x
 
  '''else'''
 
      '''if''' y == y.parent.left
 
        y.parent.left = x
 
      '''else'''
 
        y.parent.right = x
 
 
====Рекурсивная реализация====
 
====Рекурсивная реализация====
При рекурсивном удаления узла из бинарного дерева нужно рассмотреть три случая: удаляемый элемент находится в левом поддереве текущего поддерева, удаляемый элемент находится в правом поддереве или удаляемый элемент находится в корне. В двух первых случаях нужно рекурсивно удалить элемент из нужного поддерева. Если удаляемый элемент находится в корне текущего поддерева и имеет два дочерних узла, то нужно заменить его минимальным элементом из правого поддерева и рекурсивно удалить минимальный элемент из правого поддерева. Иначе, если удаляемый элемент имеет один дочерний узел, нужно заменить его потомком. Время работы алгоритма {{---}} <tex>O(h)</tex>.
+
При рекурсивном удалении узла из бинарного дерева нужно рассмотреть три случая: удаляемый элемент находится в левом поддереве текущего поддерева, удаляемый элемент находится в правом поддереве или удаляемый элемент находится в корне. В двух первых случаях нужно рекурсивно удалить элемент из нужного поддерева. Если удаляемый элемент находится в корне текущего поддерева и имеет два дочерних узла, то нужно заменить его минимальным элементом из правого поддерева и рекурсивно удалить '''этот''' минимальный элемент из правого поддерева. Иначе, если удаляемый элемент имеет один дочерний узел, нужно заменить его потомком. Время работы алгоритма {{---}} <tex>O(h)</tex>.
 
Рекурсивная функция, возвращающая дерево с удаленным элементом <tex>z</tex>:
 
Рекурсивная функция, возвращающая дерево с удаленным элементом <tex>z</tex>:
  '''Node''' delete('''Node''' root, '''Node''' z)           <font color="green">// корень поддерева, удаляемый элемент</font>
+
  '''Node''' delete(root : '''Node''', z : '''T'''):              <font color="green">// корень поддерева, удаляемый ключ</font>
   '''if''' root == null
+
   '''if''' root == ''null''
      '''return''' root
+
    '''return''' root
   '''if''' z.key < root.key
+
   '''if''' z < root.key
     root.left = remove(root.left, z)
+
     root.left = delete(root.left, z)
   '''else if''' z.key > root.key
+
   '''else if''' z > root.key
      root.right = remove(root.right, z)
+
    root.right = delete(root.right, z)
   '''else if''' root.left != null '''and''' root.right != null
+
   '''else if''' root.left != ''null'' '''and''' root.right != ''null''
      root.key = minimum(root.right).key
+
    root.key = minimum(root.right).key
      root.right = remove(root, root.right)
+
    root.right = delete(root.right, root.key)
 
   '''else'''
 
   '''else'''
      '''if''' root.left != null
+
    '''if''' root.left != ''null''
        root = t.left
+
      root = root.left
      '''else'''
+
    '''else if''' root.right != ''null''
        root = t.right
+
      root = root.right
 +
    '''else'''
 +
      root = ''null''
 
   '''return''' root
 
   '''return''' root
 +
 +
==Задачи о бинарном дереве поиска==
 +
 +
===Проверка того, что заданное дерево является деревом поиска===
 +
 +
{{Задача
 +
|definition = Определить, является ли заданное двоичное дерево деревом поиска.
 +
}}
 +
[[Файл:Not_Enough.png|right|thumb|291px|Пример дерева, для которого недостаточно проверки лишь его соседних вершин]]
 +
Для того чтобы решить эту задачу, применим [[Обход в глубину, цвета вершин|обход в глубину]]. Запустим от корня рекурсивную логическую функцию, которая выведет <tex>\mathtt{true}</tex>, если дерево является BST и <tex>\mathtt{false}</tex> в противном случае. Чтобы дерево не являлось BST, в нём должна быть хотя бы одна вершина, которая не попадает под определение дерева поиска. То есть достаточно найти всего одну такую вершину, чтобы выйти из рекурсии и вернуть значение <tex>\mathtt{false}</tex>. Если же, дойдя до листьев, функция не встретит на своём пути такие вершины, она вернёт значение <tex>\mathtt{true}</tex>.
 +
 +
Функция принимает на вход исследуемую вершину, а также два значения: <tex>\mathtt{min}</tex> и <tex>\mathtt{max}</tex>, которые до вызова функции равнялись <tex> \infty </tex> и <tex> -\infty </tex> соответственно, где <tex> \infty </tex> — очень большое число, т.е. ни один ключ дерева не превосходит его по модулю. Казалось бы, два последних параметра не нужны. Но без них программа может выдать неверный ответ, так как сравнения только вершины и её детей недостаточно. Необходимо также помнить, в каком поддереве для более старших предков мы находимся. Например, в этом дереве вершина с номером <tex>8</tex> находится левее вершины, в которой лежит <tex>5</tex>, чего не должно быть в дереве поиска, однако после проверки функция бы вернула <tex>\mathtt{true}</tex>.
 +
 +
'''bool''' isBinarySearchTree(root: '''Node'''):                    <font color="green">// Здесь root — корень заданного двоичного дерева.</font>
 +
 +
  '''bool''' check(v : '''Node''', min: '''T''', max: '''T'''):                <font color="green">// min и max — минимально и максимально допустимые значения в вершинах поддерева.</font>
 +
    '''if''' v == ''null''                    '''return''' ''true''
 +
    '''if''' v.key <= min '''or''' max <= v.key '''return''' ''false''
 +
    '''return''' check(v.left, min, v.key) '''and''' check(v.right, v.key, max)
 +
 +
  '''return''' check(root, <tex> -\infty </tex>, <tex> \infty </tex>)
 +
 +
Время работы алгоритма {{---}} <tex>O(n)</tex>, где <tex>n</tex> {{---}} количество вершин в дереве.
 +
 +
===Задачи на поиск максимального BST в заданном двоичном дереве===
 +
 +
{{Задача
 +
|definition = Найти в данном дереве такую вершину, что она будет корнем поддерева поиска с наибольшим количеством вершин.
 +
}}
 +
Если мы будем приведённым выше способом проверять каждую вершину, мы справимся с задачей за <tex>O(n^2)</tex>. Но её можно решить за <tex>O(n)</tex>, идя от корня и проверяя все вершины по одному разу, основываясь на следующих фактах:
 +
* Значение в вершине больше максимума в её левом поддереве;
 +
* Значение в вершине меньше минимума в её правом поддереве;
 +
* Левое и правое поддерево являются деревьями поиска.
 +
 +
Введём <tex>\mathtt{v.min}</tex> и <tex>\mathtt{v.max}</tex>, которые будут хранить минимум в левом поддереве вершины и максимум в правом. Тогда мы должны будем проверить, являются ли эти поддеревья деревьями поиска и, если да, лежит ли ключ вершины <tex>\mathtt{v}</tex> между этими значениями <tex>\mathtt{v.min}</tex> и <tex>\mathtt{v.max}</tex>.  Если вершина является листом, она автоматически становится деревом поиска, а её ключ {{---}} минимумом или максимумом для её родителя (в зависимости от расположения вершины). Функция <tex>\mathtt{cnt}</tex> записывает в <tex>\mathtt{v.kol}</tex> количество вершин в дереве, если оно является деревом поиска или <tex>\mathtt{-1}</tex> в противном случае. После выполнения функции ищем за линейное время вершину с наибольшим значением <tex>\mathtt{v.kol}</tex>.
 +
 +
'''int''' count(root: '''Node'''):                <font color="green">// root — корень заданного двоичного дерева.</font>
 +
 +
  '''int''' cnt(v: '''Node'''):
 +
    '''if''' v == ''null''
 +
      v.kol = 0
 +
      '''return''' = 0
 +
    '''if''' cnt(v.left) != -1 '''and''' cnt(v.right) != -1
 +
      '''if''' v.left == ''null'' '''and''' v.right == ''null''
 +
        v.min = v.key
 +
        v.max = v.key
 +
        v.kol = 1
 +
        '''return''' 1
 +
      '''if''' v.left == ''null''
 +
        '''if''' v.right.max > v.key
 +
          v.min = v.key
 +
          v.kol = cnt(v.right) + 1
 +
          '''return''' v.kol
 +
      '''if''' v.right == ''null''
 +
        '''if''' v.left.min < v.key
 +
          v.max = v.key
 +
          v.kol = cnt(v.left) + 1
 +
          '''return''' v.kol
 +
      '''if''' v.left.min < v.key '''and''' v.right.max > v.key
 +
        v.min = v.left.min
 +
        v.max = v.right.max
 +
        v.kol = v.left.kol + v.right.kol + 1
 +
        v.kol = cnt(v.left) + cnt(v.right) + 1
 +
        '''return''' v.kol
 +
    '''return''' -1
 +
 +
  '''return''' cnt(root)
 +
 +
Алгоритм работает за <tex>O(n)</tex>, так как мы прошлись по дереву два раза за время, равное количеству вершин.
 +
 +
===Восстановление дерева по результату обхода preorderTraversal===
 +
 +
{{Задача
 +
|definition = Восстановить дерево по последовательности, выведенной после выполнения процедуры <tex>\mathrm{preorderTraversal}</tex>.
 +
}}
 +
[[Файл:BST_from_seq.gif|right|thumb|257px|Восстановление дерева поиска по последовательности ключей]]
 +
 +
Как мы помним, процедура <tex>\mathrm{preorderTraversal}</tex> выводит значения в узлах поддерева следующим образом: сначала идёт до упора влево, затем на каком-то моменте делает шаг вправо и снова движется влево. Это продолжается до тех пор, пока не будут выведены все вершины. Полученная последовательность позволит нам однозначно определить расположение всех узлов поддерева. Первая вершина всегда будет в корне. Затем, пока не будут использованы все значения, будем последовательно подвешивать левых сыновей к последней добавленной вершине, пока не найдём номер, нарушающий убывающую последовательность, а для каждого такого номера будем искать вершину без правого потомка, хранящую наибольшее значение, не превосходящее того, которое хотим поставить, и подвешиваем к ней элемент с таким номером в качестве правого сына. Когда мы, желая найти такую вершину, встречаем какую-нибудь другую, уже имеющую правого сына, проходим по ветке вправо. Мы имеем на это право, так как если такая вершина стоит, то процедура обхода в ней уже побывала и поворачивала вправо, поэтому спускаться в другую сторону смысла не имеет. Вершину с максимальным ключом, с которой будем начинать поиск, будем запоминать. Она будет обновляться каждый раз, когда появится новый максимум.
 +
 +
Процедура восстановления дерева работает за <tex>O(n)</tex>.
 +
 +
 +
Разберём алгоритм на примере последовательности <tex>\mathtt{8}</tex> <tex>\mathtt{2}</tex> <tex>\mathtt{1}</tex> <tex>\mathtt{4}</tex> <tex>\mathtt{3}</tex> <tex>\mathtt{5}</tex>.
 +
 +
Будем выделять красным цветом вершины, рассматриваемые на каждом шаге, чёрным жирным {{---}} их родителей, курсивом {{---}} убывающие подпоследовательности (в случаях, когда мы их рассматриваем) или претендентов на добавление к ним правого ребёнка (когда рассматривается вершина, нарушающая убывающую последовательность).
 +
{| style="background-color:#CCC;margin:0.5px"
 +
!style="background-color:#EEE"| Состояние
 +
последовательности
 +
!style="background-color:#EEE"| Действие
 +
!style="background-color:#EEE"| Пояснение
 +
|-
 +
|style="background-color:#FFF;padding:2px 10px"|  <span style="color:red">'''8'''</span> 2 1 4 3 5
 +
|style="background-color:#FFF;padding:2px 10px"| Делаем вершину корнем.
 +
|style="background-color:#FFF;padding:2px 10px"| ''Первая вершина всегда будет корнем, так как вывод начинался с него.''
 +
|-
 +
|style="background-color:#FFF;padding:2px 10px"| '''''8''''' <span style="color:red">'''''2'''''</span> ''1'' 4 3 5
 +
|rowspan=2 style="background-color:#FFF;padding:2px 10px"|Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына.
 +
|rowspan=2 style="background-color:#FFF;padding:2px 10px"| ''Каждая последующая вершина становится левым сыном предыдущей, так как выводя ключи, мы двигались по дереву поиска влево, пока есть вершины.''
 +
|-
 +
| style="background-color:#FFF;padding:2px 10px"| ''8 '''2''''' <span style="color:red">'''''1'''''</span> 4 3 5
 +
|-
 +
|style="background-color:#FFF;padding:2px 10px"| ''8 '''2''''' 1 <span style="color:red">'''4'''</span> 3 5
 +
|style="background-color:#FFF;padding:2px 10px"| Для вершины, нарушившей убывающую последовательность, ищем максимальное значение, меньшее его. В данном случае оно равно <tex>\mathtt{2}</tex>. Затем добавляем вершину.
 +
|style="background-color:#FFF;padding:2px 10px"| ''На моменте вывода следующего номера процедура обратилась уже к какому-то из правых поддеревьев, так как влево идти уже некуда. Значит, нам необходимо найти узел, для которого данная вершина являлась бы правым сыном. Очевидно, что в её родителе не может лежать значение, которое больше её ключа. Но эту вершину нельзя подвесить и к меньшим, иначе нашёлся бы более старший предок, также хранящий какое-то значение, которое меньше, чем в исследуемой. Для этого предка вершина бы попала в левое поддерево. И тогда возникает противоречие с определением дерева поиска. Отсюда следует, что родитель определяется единственным образом {{---}} он хранит максимум среди ключей, не превосходящих значения в подвешиваемой вершине, что и требовалось доказать.''
 +
|-
 +
|style="background-color:#FFF;padding:2px 10px"| 8 2 1 '''''4''''' <span style="color:red">'''''3'''''</span> 5
 +
|style="background-color:#FFF;padding:2px 10px"| Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына.
 +
|style="background-color:#FFF;padding:2px 10px"| ''Зайдя в правое поддерево, процедура обхода снова до упора начала двигаться влево, поэтому действуем аналогичным образом.''
 +
|-
 +
|style="background-color:#FFF;padding:2px 10px"| ''8'' 2 1 '''''4''''' 3 <span style="color:red">'''5'''</span>
 +
|style="background-color:#FFF;padding:2px 10px"| Для этой вершины ищем максимальное значение, меньшее его. Затем добавляем вершину.
 +
|style="background-color:#FFF;padding:2px 10px"| ''Здесь процедура снова обратилась к правому поддереву. Рассуждения аналогичны. Ключ родителя этой вершины равен <tex>\mathtt{4}</tex>.''
 +
|}
  
 
==См. также==
 
==См. также==
 
* [[Поисковые структуры данных]]
 
* [[Поисковые структуры данных]]
 
* [[Рандомизированное бинарное дерево поиска]]
 
* [[Рандомизированное бинарное дерево поиска]]
     
+
* [[Красно-черное дерево]]
 +
* [[АВЛ-дерево]]
 +
 
 
==Источники информации==
 
==Источники информации==
 
* [https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0 Википедия {{---}} Двоичное дерево поиска]
 
* [https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0 Википедия {{---}} Двоичное дерево поиска]
Строка 188: Строка 325:
 
[[Категория: Деревья поиска]]
 
[[Категория: Деревья поиска]]
 
[[Категория: Дискретная математика и алгоритмы]]
 
[[Категория: Дискретная математика и алгоритмы]]
 +
[[Категория: Структуры данных]]

Текущая версия на 19:21, 4 сентября 2022

Бинарное дерево поиска из 9 элементов
Бинарное дерево поиска (англ. binary search tree, BST) — структура данных для работы с упорядоченными множествами.

Бинарное дерево поиска обладает следующим свойством: если [math]x[/math] — узел бинарного дерева с ключом [math]k[/math], то все узлы в левом поддереве должны иметь ключи, меньшие [math]k[/math], а в правом поддереве большие [math]k[/math].

Операции в бинарном дереве поиска

Для представления бинарного дерева поиска в памяти будем использовать следующую структуру:

struct Node:
  T key                    // ключ узла
  Node left                // указатель на левого потомка
  Node right               // указатель на правого потомка
  Node parent              // указатель на предка

Обход дерева поиска

Есть три операции обхода узлов дерева, отличающиеся порядком обхода узлов:

  • [math]\mathrm{inorderTraversal}[/math] — обход узлов в отсортированном порядке,
  • [math]\mathrm{preorderTraversal}[/math] — обход узлов в порядке: вершина, левое поддерево, правое поддерево,
  • [math]\mathrm{postorderTraversal}[/math] — обход узлов в порядке: левое поддерево, правое поддерево, вершина.
func inorderTraversal(x : Node):
   if x != null
      inorderTraversal(x.left)
      print x.key
      inorderTraversal(x.right)

При выполнении данного обхода вершины будут выведены в следующем порядке: 1 3 4 6 7 8 10 13 14.

func preorderTraversal(x : Node)
   if x != null
      print x.key
      preorderTraversal(x.left)
      preorderTraversal(x.right)

При выполнении данного обхода вершины будут выведены в следующем порядке: 8 3 1 6 4 7 10 14 13.

func postorderTraversal(x : Node)
   if x != null
      postorderTraversal(x.left)
      postorderTraversal(x.right)
      print x.key

При выполнении данного обхода вершины будут выведены в следующем порядке: 1 4 7 6 3 13 14 10 8.

Данные алгоритмы выполняют обход за время [math]O(n)[/math], поскольку процедура вызывается ровно два раза для каждого узла дерева.

Поиск элемента

Поиск элемента 4

Для поиска элемента в бинарном дереве поиска можно воспользоваться следующей функцией, которая принимает в качестве параметров корень дерева и искомый ключ. Для каждого узла функция сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае функция вызывается рекурсивно для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы [math]O(h)[/math], где [math]h[/math] — высота дерева.

Node search(x : Node, k : T):
   if x == null or k == x.key
      return x
   if k < x.key
      return search(x.left, k)
   else
      return search(x.right, k)

Поиск минимума и максимума

Чтобы найти минимальный элемент в бинарном дереве поиска, необходимо просто следовать указателям [math]left[/math] от корня дерева, пока не встретится значение [math]null[/math]. Если у вершины есть левое поддерево, то по свойству бинарного дерева поиска в нем хранятся все элементы с меньшим ключом. Если его нет, значит эта вершина и есть минимальная. Аналогично ищется и максимальный элемент. Для этого нужно следовать правым указателям.

Node minimum(x : Node):
  if x.left == null
     return x
  return minimum(x.left)
Node maximum(x : Node):
  if x.right == null
     return x
  return maximum(x.right)

Данные функции принимают корень поддерева, и возвращают минимальный (максимальный) элемент в поддереве. Обе процедуры выполняются за время [math]O(h)[/math].

Поиск следующего и предыдущего элемента

Реализация с использованием информации о родителе

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

Node next(x : Node):
   if x.right != null
      return minimum(x.right)
   y = x.parent
   while y != null and x == y.right
      x = y
      y = y.parent
   return y
Node prev(x : Node):
   if x.left != null
      return maximum(x.left)
   y = x.parent
   while y != null and x == y.left
      x = y
      y = y.parent
   return y

Обе операции выполняются за время [math]O(h)[/math].

Реализация без использования информации о родителе

Рассмотрим поиск следующего элемента для некоторого ключа [math]x[/math]. Поиск будем начинать с корня дерева, храня текущий узел [math]current[/math] и узел [math]successor[/math], последний посещенный узел, ключ которого больше [math]x[/math].
Спускаемся вниз по дереву, как в алгоритме поиска узла. Рассмотрим ключ текущего узла [math]current[/math]. Если [math]current.key \leqslant x[/math], значит следующий за [math]x[/math] узел находится в правом поддереве (в левом поддереве все ключи меньше [math]current.key[/math]). Если же [math]x \lt current.key[/math], то [math]x \lt next(x) \leqslant current.key[/math], поэтому [math]current[/math] может быть следующим для ключа [math]x[/math], либо следующий узел содержится в левом поддереве [math]current[/math]. Перейдем к нужному поддереву и повторим те же самые действия.
Аналогично реализуется операция поиска предыдущего элемента.

Node next(x : T):
   Node current = root, successor = null                // root — корень дерева
   while current != null
      if current.key > x
         successor = current
         current = current.left
      else
         current = current.right
   return successor

Вставка

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

Реализация с использованием информации о родителе

func insert(x : Node, z : Node):            // x — корень поддерева, z — вставляемый элемент
   while x != null
     if z.key > x.key
        if x.right != null
           x = x.right
        else
           z.parent = x
           x.right = z
           break
     else if z.key < x.key
        if x.left != null
           x = x.left
        else
           z.parent = x
           x.left = z
           break

Реализация без использования информации о родителе

Node insert(x : Node, z : T):               // x — корень поддерева, z — вставляемый ключ
   if x == null 
      return Node(z)                        // подвесим Node с key = z
   else if z < x.key
      x.left = insert(x.left, z)
   else if z > x.key
      x.right = insert(x.right, z)
   return x

Время работы алгоритма для обеих реализаций — [math]O(h)[/math].

Удаление

Нерекурсивная реализация

Для удаления узла из бинарного дерева поиска нужно рассмотреть три возможные ситуации. Если у узла нет дочерних узлов, то у его родителя нужно просто заменить указатель на [math]null[/math]. Если у узла есть только один дочерний узел, то нужно создать новую связь между родителем удаляемого узла и его дочерним узлом. Наконец, если у узла два дочерних узла, то нужно найти следующий за ним элемент (у этого элемента не будет левого потомка), его правого потомка подвесить на место найденного элемента, а удаляемый узел заменить найденным узлом. Таким образом, свойство бинарного дерева поиска не будет нарушено. Данная реализация удаления не увеличивает высоту дерева. Время работы алгоритма — [math]O(h)[/math].

Случай Иллюстрация
Удаление листа Bst del1.png
Удаление узла с одним дочерним узлом Bst del2.png
Удаление узла с двумя дочерними узлами Bst del3.png
func delete(t : Node, v : Node):                 // [math]t[/math] — дерево, [math]v[/math] — удаляемый элемент
   p = v.parent                                  // предок удаляемого элемента
   if v.left == null and v.right == null         // первый случай: удаляемый элемент - лист
     if p.left == v
       p.left = null
     if p.right == v
       p.right = null
   else if v.left == null or v.right == null     // второй случай: удаляемый элемент имеет одного потомка
       if v.left == null                 
           if p.left == v
             p.left = v.right
           else
             p.right = v.right
           v.right.parent = p 
       else
           if p.left == v
               p.left = v.left
           else
               p.right = v.left
           v.left.parent = p
   else                                          // третий случай: удаляемый элемент имеет двух потомков
     successor = next(v, t)                   
     v.key = successor.key
     if successor.parent.left == successor
       successor.parent.left = successor.right
       if successor.right != null
         successor.right.parent = successor.parent
     else
       successor.parent.right = successor.right
       if successor.right != null
         successor.right.parent = successor.parent

Рекурсивная реализация

При рекурсивном удалении узла из бинарного дерева нужно рассмотреть три случая: удаляемый элемент находится в левом поддереве текущего поддерева, удаляемый элемент находится в правом поддереве или удаляемый элемент находится в корне. В двух первых случаях нужно рекурсивно удалить элемент из нужного поддерева. Если удаляемый элемент находится в корне текущего поддерева и имеет два дочерних узла, то нужно заменить его минимальным элементом из правого поддерева и рекурсивно удалить этот минимальный элемент из правого поддерева. Иначе, если удаляемый элемент имеет один дочерний узел, нужно заменить его потомком. Время работы алгоритма — [math]O(h)[/math]. Рекурсивная функция, возвращающая дерево с удаленным элементом [math]z[/math]:

Node delete(root : Node, z : T):               // корень поддерева, удаляемый ключ
  if root == null
    return root
  if z < root.key
    root.left = delete(root.left, z)
  else if z > root.key
    root.right = delete(root.right, z)
  else if root.left != null and root.right != null
    root.key = minimum(root.right).key
    root.right = delete(root.right, root.key)
  else
    if root.left != null
      root = root.left
    else if root.right != null
      root = root.right
    else
      root = null
  return root

Задачи о бинарном дереве поиска

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

Задача:
Определить, является ли заданное двоичное дерево деревом поиска.
Пример дерева, для которого недостаточно проверки лишь его соседних вершин

Для того чтобы решить эту задачу, применим обход в глубину. Запустим от корня рекурсивную логическую функцию, которая выведет [math]\mathtt{true}[/math], если дерево является BST и [math]\mathtt{false}[/math] в противном случае. Чтобы дерево не являлось BST, в нём должна быть хотя бы одна вершина, которая не попадает под определение дерева поиска. То есть достаточно найти всего одну такую вершину, чтобы выйти из рекурсии и вернуть значение [math]\mathtt{false}[/math]. Если же, дойдя до листьев, функция не встретит на своём пути такие вершины, она вернёт значение [math]\mathtt{true}[/math].

Функция принимает на вход исследуемую вершину, а также два значения: [math]\mathtt{min}[/math] и [math]\mathtt{max}[/math], которые до вызова функции равнялись [math] \infty [/math] и [math] -\infty [/math] соответственно, где [math] \infty [/math] — очень большое число, т.е. ни один ключ дерева не превосходит его по модулю. Казалось бы, два последних параметра не нужны. Но без них программа может выдать неверный ответ, так как сравнения только вершины и её детей недостаточно. Необходимо также помнить, в каком поддереве для более старших предков мы находимся. Например, в этом дереве вершина с номером [math]8[/math] находится левее вершины, в которой лежит [math]5[/math], чего не должно быть в дереве поиска, однако после проверки функция бы вернула [math]\mathtt{true}[/math].

bool isBinarySearchTree(root: Node):                    // Здесь root — корень заданного двоичного дерева.

  bool check(v : Node, min: T, max: T):                 // min и max — минимально и максимально допустимые значения в вершинах поддерева.
    if v == null                    return true
    if v.key <= min or max <= v.key return false
    return check(v.left, min, v.key) and check(v.right, v.key, max)

  return check(root, [math] -\infty [/math], [math] \infty [/math])

Время работы алгоритма — [math]O(n)[/math], где [math]n[/math] — количество вершин в дереве.

Задачи на поиск максимального BST в заданном двоичном дереве

Задача:
Найти в данном дереве такую вершину, что она будет корнем поддерева поиска с наибольшим количеством вершин.

Если мы будем приведённым выше способом проверять каждую вершину, мы справимся с задачей за [math]O(n^2)[/math]. Но её можно решить за [math]O(n)[/math], идя от корня и проверяя все вершины по одному разу, основываясь на следующих фактах:

  • Значение в вершине больше максимума в её левом поддереве;
  • Значение в вершине меньше минимума в её правом поддереве;
  • Левое и правое поддерево являются деревьями поиска.

Введём [math]\mathtt{v.min}[/math] и [math]\mathtt{v.max}[/math], которые будут хранить минимум в левом поддереве вершины и максимум в правом. Тогда мы должны будем проверить, являются ли эти поддеревья деревьями поиска и, если да, лежит ли ключ вершины [math]\mathtt{v}[/math] между этими значениями [math]\mathtt{v.min}[/math] и [math]\mathtt{v.max}[/math]. Если вершина является листом, она автоматически становится деревом поиска, а её ключ — минимумом или максимумом для её родителя (в зависимости от расположения вершины). Функция [math]\mathtt{cnt}[/math] записывает в [math]\mathtt{v.kol}[/math] количество вершин в дереве, если оно является деревом поиска или [math]\mathtt{-1}[/math] в противном случае. После выполнения функции ищем за линейное время вершину с наибольшим значением [math]\mathtt{v.kol}[/math].

int count(root: Node):                 // root — корень заданного двоичного дерева.

  int cnt(v: Node):
    if v == null
      v.kol = 0
      return = 0
    if cnt(v.left) != -1 and cnt(v.right) != -1
      if v.left == null and v.right == null
        v.min = v.key
        v.max = v.key
        v.kol = 1
        return 1
      if v.left == null
        if v.right.max > v.key
          v.min = v.key
          v.kol = cnt(v.right) + 1
          return v.kol
      if v.right == null
        if v.left.min < v.key
          v.max = v.key
          v.kol = cnt(v.left) + 1
          return v.kol
      if v.left.min < v.key and v.right.max > v.key 
        v.min = v.left.min
        v.max = v.right.max
        v.kol = v.left.kol + v.right.kol + 1
        v.kol = cnt(v.left) + cnt(v.right) + 1
        return v.kol
    return -1

  return cnt(root)

Алгоритм работает за [math]O(n)[/math], так как мы прошлись по дереву два раза за время, равное количеству вершин.

Восстановление дерева по результату обхода preorderTraversal

Задача:
Восстановить дерево по последовательности, выведенной после выполнения процедуры [math]\mathrm{preorderTraversal}[/math].
Восстановление дерева поиска по последовательности ключей

Как мы помним, процедура [math]\mathrm{preorderTraversal}[/math] выводит значения в узлах поддерева следующим образом: сначала идёт до упора влево, затем на каком-то моменте делает шаг вправо и снова движется влево. Это продолжается до тех пор, пока не будут выведены все вершины. Полученная последовательность позволит нам однозначно определить расположение всех узлов поддерева. Первая вершина всегда будет в корне. Затем, пока не будут использованы все значения, будем последовательно подвешивать левых сыновей к последней добавленной вершине, пока не найдём номер, нарушающий убывающую последовательность, а для каждого такого номера будем искать вершину без правого потомка, хранящую наибольшее значение, не превосходящее того, которое хотим поставить, и подвешиваем к ней элемент с таким номером в качестве правого сына. Когда мы, желая найти такую вершину, встречаем какую-нибудь другую, уже имеющую правого сына, проходим по ветке вправо. Мы имеем на это право, так как если такая вершина стоит, то процедура обхода в ней уже побывала и поворачивала вправо, поэтому спускаться в другую сторону смысла не имеет. Вершину с максимальным ключом, с которой будем начинать поиск, будем запоминать. Она будет обновляться каждый раз, когда появится новый максимум.

Процедура восстановления дерева работает за [math]O(n)[/math].


Разберём алгоритм на примере последовательности [math]\mathtt{8}[/math] [math]\mathtt{2}[/math] [math]\mathtt{1}[/math] [math]\mathtt{4}[/math] [math]\mathtt{3}[/math] [math]\mathtt{5}[/math].

Будем выделять красным цветом вершины, рассматриваемые на каждом шаге, чёрным жирным — их родителей, курсивом — убывающие подпоследовательности (в случаях, когда мы их рассматриваем) или претендентов на добавление к ним правого ребёнка (когда рассматривается вершина, нарушающая убывающую последовательность).

Состояние

последовательности

Действие Пояснение
8 2 1 4 3 5 Делаем вершину корнем. Первая вершина всегда будет корнем, так как вывод начинался с него.
8 2 1 4 3 5 Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына. Каждая последующая вершина становится левым сыном предыдущей, так как выводя ключи, мы двигались по дереву поиска влево, пока есть вершины.
8 2 1 4 3 5
8 2 1 4 3 5 Для вершины, нарушившей убывающую последовательность, ищем максимальное значение, меньшее его. В данном случае оно равно [math]\mathtt{2}[/math]. Затем добавляем вершину. На моменте вывода следующего номера процедура обратилась уже к какому-то из правых поддеревьев, так как влево идти уже некуда. Значит, нам необходимо найти узел, для которого данная вершина являлась бы правым сыном. Очевидно, что в её родителе не может лежать значение, которое больше её ключа. Но эту вершину нельзя подвесить и к меньшим, иначе нашёлся бы более старший предок, также хранящий какое-то значение, которое меньше, чем в исследуемой. Для этого предка вершина бы попала в левое поддерево. И тогда возникает противоречие с определением дерева поиска. Отсюда следует, что родитель определяется единственным образом — он хранит максимум среди ключей, не превосходящих значения в подвешиваемой вершине, что и требовалось доказать.
8 2 1 4 3 5 Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына. Зайдя в правое поддерево, процедура обхода снова до упора начала двигаться влево, поэтому действуем аналогичным образом.
8 2 1 4 3 5 Для этой вершины ищем максимальное значение, меньшее его. Затем добавляем вершину. Здесь процедура снова обратилась к правому поддереву. Рассуждения аналогичны. Ключ родителя этой вершины равен [math]\mathtt{4}[/math].

См. также

Источники информации