Викиконспекты - Вклад участника [ru]

Левосторонние красно-чёрные деревья

2018-06-27T21:32:04Z

188.227.117.250:

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево. Первая операция трансформируют <tex>3</tex>-узел (совокупность из <tex>3</tex> узлов, где <tex>2</tex> узла являются наследниками третьего, причем одна из связей является красной), левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

==Удаление максимума==
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T12:33:25Z

188.227.117.250: /* Вращения */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево. Первая операция трансформируют <tex>3</tex>-узел (совокупность из <tex>3</tex> узлов, где <tex>2</tex> узла являются наследниками третьего, причем одна из связей является красной), левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T12:26:15Z

188.227.117.250: /* Вращения */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел (совокупность из <tex>3</tex> узлов, где <tex>2</tex> узла являются наследниками третьего, причем одна из связей является красной), левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T12:25:55Z

188.227.117.250: /* Вращения */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел(совокупность из <tex>3</tex> узлов, где <tex>2</tex> узла являются наследниками третьего, причем одна из связей является красной), левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T12:25:42Z

188.227.117.250: /* Вращения */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел(совокупность из <tex>3</tex> узлов, где tex>2</tex> узла являются наследниками третьего, причем одна из связей является красной), левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:44:50Z

188.227.117.250: /* Свойства */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний нулевой узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:43:24Z

188.227.117.250: /* Свойства */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:42:48Z

188.227.117.250: /* Свойства */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда черный в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.

==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:11:22Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:11:05Z

188.227.117.250: /* Исправление правых красных связей */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' h

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:10:46Z

188.227.117.250: /* Исправление правых красных связей */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' h

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:10:25Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:10:00Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
''return'' h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:09:42Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
return h

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:09:10Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if isRed(h.right.left)
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if h.left == ''null''
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:08:48Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' h.right == ''null''
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:08:00Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == ''null'')
return ''null''
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:07:00Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''if''' key = x.key
'''return''' x.val
'''else'''
'''if''' key < x.key
x = x.left
'''else'''
'''if''' key > x.key
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T11:05:43Z

188.227.117.250: /* Удаление */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Исправление правых красных связей==
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:41:08Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key = h.key
h.val = value
'''else'''
'''if''' key < h.key
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:38:13Z

188.227.117.250: /* Вставка */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]
*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:37:25Z

188.227.117.250: /* Вставка */

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:35:53Z

188.227.117.250:

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Вращения==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.
===Псевдокод===
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
==Переворот цветов==
В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.
===Псевдокод===
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:31:42Z

188.227.117.250:

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
*Корневой узел всегда ЧЕРНЫЙ в цвете.
*Каждый новый узел всегда окрашен в красный цвет.
*Каждый дочерний узел листа дерева считается черным.
==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:28:45Z

188.227.117.250:

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска, гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
Красно-чёрным называется бинарное поисковое дерево, у которого каждому узлу сопоставлен дополнительный атрибут — цвет и для которого выполняются следующие свойства:
*Каждый узел промаркирован красным или чёрным цветом
*Корень и конечные узлы (листья) дерева — чёрные
*У красного узла родительский узел — чёрный
*Все простые пути из любого узла x до листьев содержат одинаковое количество чёрных узлов
*Чёрный узел может иметь чёрного родителя
==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-20T10:28:19Z

188.227.117.250:

{{Определение
|definition = Левостороннее красно-черное дерево {{---}} тип сбалансированного двоичного дерева поиска,гарантирующий такую же асимптотическую сложность операций, как у красно-черного дерева поиска.
}}

==Свойства==
Красно-чёрным называется бинарное поисковое дерево, у которого каждому узлу сопоставлен дополнительный атрибут — цвет и для которого выполняются следующие свойства:
*Каждый узел промаркирован красным или чёрным цветом
*Корень и конечные узлы (листья) дерева — чёрные
*У красного узла родительский узел — чёрный
*Все простые пути из любого узла x до листьев содержат одинаковое количество чёрных узлов
*Чёрный узел может иметь чёрного родителя
==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:57:46Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Свойства==
Красно-чёрным называется бинарное поисковое дерево, у которого каждому узлу сопоставлен дополнительный атрибут — цвет и для которого выполняются следующие свойства:
*Каждый узел промаркирован красным или чёрным цветом
*Корень и конечные узлы (листья) дерева — чёрные
*У красного узла родительский узел — чёрный
*Все простые пути из любого узла x до листьев содержат одинаковое количество чёрных узлов
*Чёрный узел может иметь чёрного родителя
==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:55:26Z

188.227.117.250:

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Свойства==
Красно-чёрным называется бинарное поисковое дерево, у которого каждому узлу сопоставлен дополнительный атрибут — цвет и для которого выполняются следующие свойства:
*Каждый узел промаркирован красным или чёрным цветом
*Корень и конечные узлы (листья) дерева — чёрные
*У красного узла родительский узел — чёрный
*Все простые пути из любого узла x до листьев содержат одинаковое количество чёрных узлов
*Чёрный узел может иметь чёрного родителя
==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:51:34Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:51:07Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:50:46Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
''if''' key > h.key
cmp = 1
'''else'''
cmp = 0
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:47:43Z

188.227.117.250: /* Вставка */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
'''return''' new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:47:23Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:46:49Z

188.227.117.250: /* Удаление минимума */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:46:31Z

188.227.117.250: /* Удаление */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:46:06Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:45:23Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:44:52Z

188.227.117.250: /* Псевдокод */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:43:07Z

188.227.117.250: /* Вставка */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем переворот цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:42:24Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:41:05Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = '''!''' h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:39:51Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log_2(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:37:15Z

188.227.117.250:

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов на любом пути от корня до листа, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:36:24Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left = x.right
x.right = h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:34:47Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]
'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:34:32Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:34:15Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:33:56Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:33:41Z

188.227.117.250: /* Переворот цветов */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]

Левосторонние красно-чёрные деревья

2018-06-18T12:33:01Z

188.227.117.250: /* Вращения */

{{Определение
|definition = Левосторонние красно-черные деревья {{---}} двоичные деревья поиска, в котором баланс осуществляется на основе "цвета" узла дерева, который принимает только два значения: "красный" и "чёрный". Данный тип [[Красно-черное дерево|красно-черных деревьев]] имеет ряд преимуществ над классической структурой. Разработан Робертом Соджевиском в <tex>2008</tex> году.
}}

==Переворот цветов==
Чтобы поддерживать левосторонние красно-черные двоичные деревья поиска необходимо соблюдать следующие инварианты при вставке и удалении:
* Ни один путь от корня до листьев дерева не содержит двух последовательных красных узлов.
* Количество черных узлов на каждом таком пути одинаково.
Из этих инвариантов следует, что длина каждого пути от корня до листьев в красно-черном дереве с <tex>N</tex> узлами не превышает <tex>2 \cdot \log(N)</tex> .

Основные операции, используемые алгоритмами сбалансированного дерева для поддержания баланса при вставке и удалении, называются вращением вправо и вращением влево.Первая операция трансформируют <tex>3</tex>-узел, левый потомок которого окрашен в красный, в <tex>3</tex>-узел, правый потомок которого окрашен в красный,вторая операция {{---}} наоборот. Вращения сохраняют два указанных выше инварианта, не изменяют поддеревья узла.

==Переворот цветов==
[[File:rotateRight.png|310px|thumb|upright|Rotate Right]]
'''Node''' rotateRight(h : '''Node''')
x = h.left
h.left= x.right
x.right= h
x.color = h.color
h.color = RED
'''return''' x
[[File:rotateLeft.png|310px|thumb|upright|Rotate Left]]
'''Node''' rotateLeft(h : '''Node''')
x = h.right
h.right = x.left
x.left = h
x.color = h.color
h.color = RED
'''return''' x

В красно-черных деревьях используется такая операция как '''переворот цветов''' , которая инвертирует цвет узла и двух его детей. Она не изменяет количество черных узлов при любом обходе от корня до листьев дерева, но может привести к появлению двух последовательных красных узлов.
[[File: ColorFlip.png|320px|thumb|upright| Переворот цветов]]

'''void''' flipColors(h : '''Node''' h)
h.color = '''!''' h.color
h.left.color = '''!''' h.left.color
h.right.color = <tex> !</tex> h.right.color

==Вставка==
Вставка в ЛСКЧД базируется на <tex>4</tex> простых операциях:

*Вставка нового узла к листу дерева:
Если высота узла нулевая, возвращаем новый красный узел.
[[File:insertNode.png|310px|thumb|upright|Вставка нового узла]]

'''if''' (h == '''null''')
return new Node(key, value, RED)

*Расщепление узла с <tex>4</tex>-я потомками:
Если левый предок и правый предок красные, запускаем вращение цветов от текущего узла.
[[File:Split4node.png|310px|thumb|upright|Расщепление узла]]
'''if''' (isRed(h.left) '''&&''' isRed(h.right))
colorFlip(h)

*Принудительное вращение влево:
[[File:Enforce.png|310px|thumb|upright|Принудительное вращение]]
Если правый предок красный, вращаем текущую вершину влево.
'''if''' (isRed(h.right))
h = rotateLeft(h)

*Балансировка узла с <tex>4</tex>-я потомками:
[[File:Balance4node.png|310px|thumb|Балансировка]]
Если левый предок красный и левый предок левого предка красный, то вращаем текущую вершину вправо.
'''if''' (isRed(h.left) && isRed(h.left.left))
h = rotateRight(h)

===Псевдокод===
'''void''' insert(key : '''Key''', value : '''Value''' )
root = insert(root, key, value)
root.color = BLACK

'''Node''' insert(h : '''Node''', key : '''Key''', value : '''Value''')
// Вставка нового листа
'''if''' h == ''null''
'''return''' '''new''' Node(key, value)
// Расщепление узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
// Стандартная вставка [[Дерево поиска, наивная реализация|в дереве поиска]]
'''int''' cmp = key.compareTo(h.key)
'''if''' cmp == 0
h.val = value
'''else'''
'''if''' cmp < 0
h.left = insert(h.left, key, value)
'''else'''
h.right = insert(h.right, key, value)
// Принудительное вращение влево
'''if''' isRed(h.right) '''&&''' '''!'''isRed(h.left)
h = rotateLeft(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
'''return''' ''h''

==Поиск==
Поиск в левосторонних красно-черных деревьях эквивалентен поиску в [[Дерево поиска, наивная реализация|наивной реализации дерева поиска]].
Для поиска элемента в красно-черных деревьях дереве поиска можно воспользоваться циклом,который проходит от корня до искомого элемента. Если же элемент отсутствует, цикл пройдет до листа дерева и прервется. Для каждого узла цикл сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае цикл повторяет для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
===Псевдокод===
'''Value''' search(key : '''Key''')
'''Node''' x = root
'''while''' (x '''!'''= null)
'''int''' cmp = key.compareTo(x.key)
'''if''' cmp == 0
'''return''' x.val
'''else'''
'''if''' cmp < 0
x = x.left
'''else'''
'''if''' cmp > 0
x = x.right
'''return''' ''null''

==Удаление==
===Исправление правых красных связей===
*Использование Переворота цветов и вращений сохраняет баланс черной связи.
*После удаления необходимо исправить правые красные связи и устранить узлы с <tex>4</tex>-я потомками
// Исправление правых красных связей
'''Node''' fixUp(h : '''Node''')
'''if''' isRed(h.right)
h = rotateLeft(h)
// Вращение <tex>2</tex>-ой красной пары пары
'''if''' isRed(h.left) '''&&''' isRed(h.left.left)
h = rotateRight(h)
// Балансировка узла с <tex>4</tex>-я потомками
'''if''' isRed(h.left) '''&&''' isRed(h.right)
colorFlip(h)
'''return''' ''h''

===Удаление максимума===
* Спускаемся вниз по правому краю дерева.
* Если поиск заканчивается на узле с <tex>4</tex>-мя или <tex>5</tex>-ю потомками, просто удаляем узел.

[[File:34-nodeRemove.png|310px|thumb|center| Узлы до и после удаления]]
* Удаление узла с <tex>2</tex>-я потомками нарушает баланс
Соответственно, спускаясь вниз по дереву необходимо поддерживать следующий инвариант : количество потомков узла не должно быть ровно <tex>2</tex>-м.
[[File:changeNode.png|600px|thumb|center| ]]

Будем поддерживать инвариант: для любого узла либо сам узел, либо правый предок узла '''красный'''.
Будем придерживаться тактики , что удалять лист легче, чем внутренний узел.

Заметим, что если правый потомок вершины и правый потомок правого потомка вершины черные, необходимо переместить левую красную ссылку вправо для сохранения инварианта.
[[File:MinEasy.png|400px|thumb|right| Перемещение красной ссылки. Простой случай]]

[[File:MinHard.png|400px|thumb|right| Перемещение красной ссылки. Сложный случай]]

===Псевдокод===
'''void''' deleteMax()
root = deleteMax(root)
root.color = BLACK

'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
'''if''' isRed(h.right.left
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''Node''' deleteMax(h : '''Node''')
'''if''' isRed(h.left)
// вращаем все 3-вершины вправо
h = rotateRight(h)
// поддерживаем инвариант (h должен быть красным)
'''if''' (h.right == '''null''')
return null
// заимствуем у брата если необходимо
'''if''' !isRed(h.right) '''&&''' !isRed(h.right.left)
h = moveRedRight(h)
// опускаемся на один уровень глубже 
h.left = deleteMax(h.left)
// исправление правых красных ссылок и 4-вершин на пути вверх
'''return''' fixUp(h)

==Удаление минимума==
Поддерживаем инвариант: вершина или левый ребенок вершины красный.

Заметим, что если левый потомок вершины и левый потомок левого потомка вершины черные, необходимо переместить красную ссылку для сохранения инварианта.
[[File:MoveRedLeftEasy.png.png |400px|thumb|upright|Перемещение красной ссылки. Простой случай]]
[[File:MoveRedLeftNoEasy.png|400px|thumb|upright|Перемещение красной ссылки. Сложный случай]]
===Псевдокод===
'''Node''' moveRedLeft(h : '''Node''')
colorFlip(h)
if (isRed(h.right.left))
h.right = rotateRight(h.right)
h = rotateLeft(h)
colorFlip(h)
'''return''' ''h''

'''void''' deleteMin()
root = deleteMin(root)
root.color = BLACK

'''Node''' deleteMin(h : '''Node''')
// удаляем узел на нижнем уровне(h должен быть красным по инварианту)
if (h.left == ''null'')
'''return''' ''null''
// Если необходимо, пропушим красную ссылку вниз
'''if (!'''isRed(h.left) '''&& !'''isRed(h.left.left))
h = moveRedLeft(h)
// опускаемся на уровень ниже 
h.left = deleteMin(h.left)
'''return''' fixUp(h)

==Асимптотика==
Асимптотика методов в левосторонних красно-черных деревьях эквивалентна асимптотике [[Красно-черное дерево|базовой реализации красно-черных деревьях]].

== См.также ==
*[[Красно-черное дерево]]
*[[Дерево поиска, наивная реализация]]
==Источники информации==
* Robert Sedgewick "Left-leaning Red-Black Trees" ,Department of Computer Science, Princeton University
[[Категория: Алгоритмы и структуры данных]]