Просмотр кода страницы Красно-чёрное дерево

{{Структура_данных
|name=Красно-чёрное дерево
|type=дерево поиска
|invented_by=[[Байер, Рудольф|Рудольф Байер]]
|invented_year=1972
|space_avg=O(n)
|space_worst=O(n)
|search_avg=O(log n)
|search_worst=O(log n)
|insert_avg=O(log n)
|insert_worst=O(log n)
|delete_avg=O(log n)
|delete_worst=O(log n)
}}

'''Красно-чёрное дерево''' ({{lang-en|red-black tree}}, {{lang-en2|RB tree}}) — один из видов самобалансирующихся [[Двоичное дерево поиска|двоичных деревьев поиска]], гарантирующих [[логарифм]]ический рост [[Словарь терминов теории графов#В|высоты дерева]] от числа [[Словарь терминов теории графов#У|узлов]] и позволяющее быстро выполнять [[Двоичное дерево (структура данных)#Основные операции в двоичном дереве поиска|основные операции]] дерева поиска: добавление, удаление и поиск узла. [[АВЛ-дерево|Сбалансированность]] достигается за счёт введения дополнительного атрибута узла дерева — «цвета». Этот атрибут может принимать одно из двух возможных значений — «чёрный» или «красный».

Изобретателем красно-чёрного дерева считают немца [[Байер, Рудольф|Рудольфа Байера]]. Название «красно-чёрное дерево» структура данных получила в статье [[Гимбас, Леонидас|Л. Гимбаса]] и [[Седжвик, Роберт|Р. Седжвика]] (1978). По словам Гимбаса, они использовали ручки двух цветов<ref name="stackex">{{Cite web |url=https://softwareengineering.stackexchange.com/questions/116614/where-does-the-term-red-black-tree-come-from/116621#116621 |title=data structures - Where does the term "Red/Black Tree" come from? - Software Engineering Stack Exchange |access-date=2019-01-04 |archive-date=2019-01-05 |archive-url=https://web.archive.org/web/20190105042824/https://softwareengineering.stackexchange.com/questions/116614/where-does-the-term-red-black-tree-come-from/116621#116621 |deadlink=no }}</ref>. По словам Седжвика, красный цвет лучше всех смотрелся на лазерном принтере<ref name="stackex" /><ref>[https://class.coursera.org/algo-004/lecture/76 Курс «Algorithms: Design and Analysis, Part 1», лекция «Red-Black Trees»] {{Wayback|url=https://class.coursera.org/algo-004/lecture/76 |date=20140825054858 }} (Видео 5:07){{ref-en}}</ref>.

Красно-чёрное дерево используется для организации сравнимых данных, таких как фрагменты текста или числа. [[Дерево (структура данных)#Листовые узлы|Листовые узлы]] красно-чёрных деревьев не содержат данных, благодаря чему не требуют выделения памяти — достаточно записать в узле-предке в качестве указателя на потомка нулевой указатель. Однако в некоторых реализациях для упрощения алгоритма могут использоваться явные листовые узлы.

== Принцип организации ==
[[Файл:Red-black tree example.svg|thumb|right|500px|Пример красно-чёрного дерева]]

Красно-чёрное дерево — [[двоичное дерево поиска]], в котором каждый узел имеет атрибут ''цвета''. При этом:

# Узел может быть либо красным, либо чёрным и имеет двух потомков;
# Корень — как правило чёрный. Это правило слабо влияет на работоспособность модели, так как цвет корня всегда можно изменить с чёрного на красный;
# Все листья, не содержащие данных — чёрные.
# Оба потомка каждого красного узла — чёрные.
# Любой простой путь от узла-предка до листового узла-потомка содержит одинаковое число чёрных узлов.

Благодаря этим ограничениям путь от корня до самого дальнего листа не более чем вдвое длиннее, чем до самого ближнего, и дерево примерно сбалансировано. Операции вставки, удаления и поиска требуют в худшем случае времени, пропорционального длине дерева, что позволяет красно-чёрным деревьям в худшем случае быть более эффективными, чем обычные двоичные деревья поиска.

Чтобы понять, как это работает, достаточно рассмотреть эффект свойств 4 и 5 вместе. Пусть для красно-чёрного дерева T число чёрных узлов от корня до листа равно B. Тогда кратчайший возможный путь до любого листа содержит B узлов и все они чёрные. Более длинный возможный путь может быть построен путём включения красных узлов. Однако, благодаря пункту 4 в дереве не может быть двух красных узлов подряд, а согласно пунктам 2 и 3, путь начинается и кончается чёрным узлом. Поэтому самый длинный возможный путь состоит из 2B-1 узлов, попеременно красных и чёрных.

Если разрешить нелистовому узлу иметь меньше двух потомков, а листовым — содержать данные, дерево сохраняет основные свойства, но алгоритмы работы с ним усложнятся. Поэтому в статье рассматриваются только «фиктивные листовые узлы», которые не содержат данных и просто служат для указания, где дерево заканчивается. Эти узлы могут быть опущены в некоторых иллюстрациях. Из пункта 5, также следует, что потомками красного узла могут быть либо два чёрных промежуточных узла, либо два чёрных листа, а с учётом пунктов 3 и 4 — что если у чёрного узла один из потомков — листовой узел, то вторым должен быть либо тоже листовой, либо вышеописанная конструкция из одного красного и двух листовых.

Также в литературе встречается трактовка, в которой в красный/чёрный цвета раскрашивают не сами узлы, а ведущие к ним рёбра — но это не имеет большого значения для понимания принципа его работы.

=== Аналогия с B-деревом с параметром 4 ===
[[Файл:Red-black tree example (B-tree analogy).svg|500px|thumb|right|То же самое красно-чёрное дерево, что и в примере выше, представленное как B-дерево.]]
Красно-чёрное дерево схоже по структуре с [[B-дерево]]м с параметром 4, в котором каждый узел может содержать от 1 до 3 значений и, соответственно, от 2 до 4 указателей на потомков. В таком В-дереве каждый узел будет содержать только одно значение, соответствующее значению чёрного узла красно-чёрного дерева с необязательным значениями до и/или после него в том же узле, оба из которых соответствуют эквивалентным красным узлам красно-чёрного дерева.

Один из способов увидеть эту эквивалентность — «поднять» красные узлы в графическом представлении красно-чёрного дерева так, чтобы они оказались на одном уровне по горизонтали со своими предками чёрными узлами, образуя страницу. В В-дереве, или в модифицированном графическом представлении красно-чёрного дерева, у всех листовых узлов глубина одинаковая.

Этот тип В-дерева является более общим, чем красно-чёрное дерево, хотя, как видно, из одного такого В-дерева с параметром 2 могут быть получены несколько красно-чёрных деревьев. Если страница В-дерева содержит только одно значение, данный узел чёрный и имеет двух потомков. Если страница содержит три значения, то центральный узел является чёрным, а каждый его сосед — красным. Однако, если страница содержит два значения, любой узел может стать чёрным в красно-чёрном дереве (и тогда второй будет красным).

== Работа с красно-чёрными деревьями ==
Красно-чёрные деревья являются одними из наиболее активно используемых на практике самобалансирующихся деревьев поиска.
В частности, контейнеры <tt>set</tt> и <tt>map</tt> в большинстве реализаций библиотеки [[Стандартная библиотека шаблонов|STL]] языка [[C++]]<ref>[http://www.drdobbs.com/184410531;jsessionid=N5J5S5BRSRIEZQE1GHRSKH4ATMY32JVN?pgno=1 Dr Dobbs — STL’s Red-Black Trees]</ref>, класс TreeMap языка [[Java]]<ref>{{Cite web |url=http://docs.oracle.com/javase/6/docs/api/java/util/TreeMap.html |title=Класс TreeMap |access-date=2015-03-13 |archive-date=2015-03-18 |archive-url=https://web.archive.org/web/20150318044009/http://docs.oracle.com/javase/6/docs/api/java/util/TreeMap.html |deadlink=no }}</ref>, так же, как и многие другие
реализации [[Ассоциативный массив|ассоциативного массива]] в различных библиотеках,
основаны на красно-чёрных деревьях.

Красно-чёрные деревья более популярны, чем идеально сбалансированные деревья, т.к. в последних может тратиться слишком много ресурсов на операции удаления из дерева и поддержание необходимой сбалансированности. После вставки или удаления требуется операция перекраски, требующая (O(log ''n'') или O(1)) смен цветов (что на практике довольно быстро) и не более чем трёх поворотов дерева (для вставки — не более двух). Хотя вставка и удаление сложны, их трудоёмкость остается O(log ''n'').

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

* Свойство 3 (Все листья чёрные) выполняется всегда.
* Свойство 4 (Оба потомка любого красного узла — чёрные) может нарушиться только при добавлении красного узла, при перекрашивании чёрного узла в красный или при повороте.
* Свойство 5 (Все пути от любого узла до листовых узлов содержат одинаковое число чёрных узлов) может нарушиться только при добавлении чёрного узла, перекрашивании красного узла в чёрный (или наоборот), или при повороте.

: ''Примечание'': Буквой '''N''' будем обозначать текущий узел (окрашенный красным). Сначала это новый узел, который вставляется, но эта процедура может применяться рекурсивно к другим узлам (смотрите случай 3). '''P''' будем обозначать предка '''N''', через '''G''' обозначим дедушку '''N''', а '''U''' будем обозначать дядю (узел, имеющий общего родителя с узлом '''P'''). Отметим, что в некоторых случаях роли узлов могут меняться, но, в любом случае, каждое обозначение будет представлять тот же узел, что и в начале. Любой цвет, изображенный на рисунке, либо предполагается в данном случае, либо получается из других соображений.
Каждый случай рассматривается с примерами кода на [[Си (язык программирования)|языке C]]. Определение структуры узла может выглядеть следующим образом:

<source lang="c">
enum node_colors { RED, BLACK };

struct node {
	struct node *parent, *left, *right;
	enum node_colors color;
	int key;
};

</source>Дядя и дедушка текущего узла могут быть найдены с помощью функций:

<source lang="c">
struct node *
grandparent(struct node *n)
{
	if ((n != NULL) && (n->parent != NULL))
		return n->parent->parent;
	else
		return NULL;
}

struct node *
uncle(struct node *n)
{
	struct node *g = grandparent(n);
	if (g == NULL)
		return NULL; // No grandparent means no uncle
	if (n->parent == g->left)
		return g->right;
	else
		return g->left;
}
</source>

Левый и правый поворот дерева может быть выполнен так:<syntaxhighlight lang="c">
void
rotate_left(struct node *n)
{
    struct node *pivot = n->right;
	
    pivot->parent = n->parent; /* при этом, возможно, pivot становится корнем дерева */
    if (n->parent != NULL) {
        if (n->parent->left==n)
            n->parent->left = pivot;
        else
            n->parent->right = pivot;
    }		
	
    n->right = pivot->left;
    if (pivot->left != NULL)
        pivot->left->parent = n;

    n->parent = pivot;
    pivot->left = n;
}

void
rotate_right(struct node *n)
{
    struct node *pivot = n->left;
	
    pivot->parent = n->parent; /* при этом, возможно, pivot становится корнем дерева */
    if (n->parent != NULL) {
        if (n->parent->left==n)
            n->parent->left = pivot;
        else
            n->parent->right = pivot;
    }		
	
    n->left = pivot->right;
    if (pivot->right != NULL)
        pivot->right->parent = n;

    n->parent = pivot;
    pivot->right = n;
}
</syntaxhighlight>'''Случай 1:''' Текущий узел '''N''' в корне дерева. В этом случае, он перекрашивается в чёрный цвет, чтобы оставить верным Свойство 2 (Корень — чёрный). Так как это действие добавляет один чёрный узел в каждый путь, Свойство 5 (Все пути от любого данного узла до листовых узлов содержат одинаковое число чёрных узлов) не нарушается.

<source lang="c">
void
insert_case1(struct node *n)
{
	if (n->parent == NULL)
		n->color = BLACK;
	else
		insert_case2(n);
}
</source>

'''Случай 2:''' Предок '''P''' текущего узла чёрный, то есть Свойство 4 (Оба потомка каждого красного узла — чёрные) не нарушается. В этом случае дерево остаётся корректным. Свойство 5 (Все пути от любого данного узла до листовых узлов содержат одинаковое число чёрных узлов) не нарушается, потому что текущий узел '''N''' имеет двух чёрных листовых потомков, но так как '''N''' является красным, путь до каждого из этих потомков содержит такое же число чёрных узлов, что и путь до чёрного листа, который был заменен текущим узлом, так что свойство остается верным.

<source lang="c">
void
insert_case2(struct node *n)
{
	if (n->parent->color == BLACK)
		return; /* Tree is still valid */
	else
		insert_case3(n);
}
</source>

: ''Примечание:'' В следующих случаях предполагается, что у '''N''' есть дедушка '''G''', так как его родитель '''P''' является красным, а если бы он был корнем, то был бы окрашен в чёрный цвет. Таким образом, '''N''' также имеет дядю '''U''', хотя он может быть листовым узлом в случаях 4 и 5.

{|
|[[Файл:Red-black tree insert case 3.png|right|Схема случая 3]]
'''Случай 3:''' Если и родитель '''P,''' и дядя '''U''' — красные, то они оба могут быть перекрашены в чёрный, и дедушка '''G''' станет красным (для сохранения свойства 5 (Все пути от любого данного узла до листовых узлов содержат одинаковое число чёрных узлов)). Теперь у текущего красного узла '''N''' чёрный родитель. Так как любой путь через родителя или дядю должен проходить через дедушку, число чёрных узлов в этих путях не изменится. Однако, дедушка '''G''' теперь может нарушить свойства 2 (Корень — чёрный) или 4 (Оба потомка каждого красного узла — чёрные) (свойство 4 может быть нарушено, так как родитель '''G''' может быть красным). Чтобы это исправить, вся процедура рекурсивно выполняется на '''G''' из случая 1.
|}
<source lang="c">
void
insert_case3(struct node *n)
{
	struct node *u = uncle(n), *g;

	if ((u != NULL) && (u->color == RED)) {
	// && (n->parent->color == RED) Второе условие проверяется в insert_case2, то есть родитель уже является красным.
		n->parent->color = BLACK;
		u->color = BLACK;
		g = grandparent(n);
		g->color = RED;
		insert_case1(g);
	} else {
		insert_case4(n);
	}
}
</source>

: ''Примечание:'' В оставшихся случаях предполагается, что родитель '''P''' является левым потомком своего предка. Если это не так, необходимо поменять ''лево'' и ''право''. Примеры кода позаботятся об этом.
{|
|[[Файл:Red-black tree insert case 4.png|left|Схема случая 4]]
'''Случай 4:''' Родитель '''P''' является красным, но дядя '''U''' — чёрный. Также, текущий узел '''N''' — правый потомок '''P''', а '''P''' в свою очередь — левый потомок своего предка '''G'''. В этом случае может быть произведен поворот дерева, который меняет роли текущего узла '''N''' и его предка '''P'''. Тогда, для бывшего родительского узла '''P''' в обновленной структуре используем случай 5, потому что Свойство 4 (Оба потомка любого красного узла — чёрные) все ещё нарушено. Вращение приводит к тому, что некоторые пути (в поддереве, обозначенном «1» на схеме) проходят через узел '''N''', чего не было до этого. Это также приводит к тому, что некоторые пути (в поддереве, обозначенном «3») не проходят через узел '''P'''. Однако, оба эти узла являются красными, так что Свойство 5 (Все пути от любого данного узла до листовых узлов содержат одинаковое число чёрных узлов) не нарушается при вращении. Однако Свойство 4 всё ещё нарушается, но теперь задача сводится к Случаю 5.
|}
<source lang="c">
void
insert_case4(struct node *n)
{
	struct node *g = grandparent(n);

	if ((n == n->parent->right) && (n->parent == g->left)) {
		rotate_left(n->parent);
		n = n->left;

		/*
		 * rotate_left может быть выполнен следующим образом, учитывая что уже есть *g =  grandparent(n) 
		 *
		 * struct node *saved_p=g->left, *saved_left_n=n->left;
		 * g->left=n; 
		 * n->left=saved_p;
		 * saved_p->right=saved_left_n;
		 * 
		 */
	} else if ((n == n->parent->left) && (n->parent == g->right)) {
		rotate_right(n->parent);
		n = n->right;

		/*
		 * rotate_right может быть выполнен следующим образом, учитывая что уже есть *g =  grandparent(n) 
		 *
		 * struct node *saved_p=g->right, *saved_right_n=n->right;
		 * g->right=n; 
		 * n->right=saved_p;
		 * saved_p->left=saved_right_n;
		 * 
		 */
	}
	insert_case5(n);
}
</source>

{|
|[[Файл:Red-black tree insert case 5.png|right|Схема случая 5]]
'''Случай 5:''' Родитель '''P''' является красным, но дядя '''U''' — чёрный, текущий узел '''N''' — левый потомок '''P''' и '''P''' — левый потомок '''G'''. В этом случае выполняется поворот дерева на '''G'''. В результате получается дерево, в котором бывший родитель '''P''' теперь является родителем и текущего узла '''N''' и бывшего дедушки '''G'''. Известно, что '''G''' — чёрный, так как его бывший потомок '''P''' не мог бы в противном случае быть красным (без нарушения Свойства 4). Тогда цвета '''P''' и '''G''' меняются и в результате дерево удовлетворяет Свойству 4 (Оба потомка любого красного узла — чёрные). Свойство 5 (Все пути от любого данного узла до листовых узлов содержат одинаковое число чёрных узлов) также остается верным, так как все пути, которые проходят через любой из этих трех узлов, ранее проходили через '''G''', поэтому теперь они все проходят через '''P'''. В каждом случае, из этих трёх узлов только один окрашен в чёрный.
|}
<source lang="c">
void
insert_case5(struct node *n)
{
	struct node *g = grandparent(n);

	n->parent->color = BLACK;
	g->color = RED;
	if ((n == n->parent->left) && (n->parent == g->left)) {
		rotate_right(g);
	} else {
		rotate_left(g);
	}
}
</source>

=== Удаление ===
При удалении узла с двумя нелистовыми потомками в обычном двоичном дереве поиска мы ищем либо наибольший элемент в его левом поддереве, либо наименьший элемент в его правом поддереве и перемещаем его значение в удаляемый узел. Затем мы удаляем узел, из которого копировали значение. Копирование значения из одного узла в другой не нарушает свойств красно-чёрного дерева, так как структура дерева и цвета узлов не изменяются. Стоит заметить, что новый удаляемый узел не может иметь сразу два дочерних нелистовых узла, так как в противном случае он не будет являться наибольшим/наименьшим элементом. Таким образом, получается, что случай удаления узла, имеющего два нелистовых потомка, сводится к случаю удаления узла, содержащего как максимум один дочерний нелистовой узел. Поэтому дальнейшее описание будет исходить из предположения существования у удаляемого узла не более одного нелистового потомка.

Будем использовать обозначение '''M''' для удаляемого узла; через '''C''' обозначим потомка '''M''', который также будем называть просто «его потомок». Если '''M''' имеет нелистового потомка, возьмем его за '''C'''. В противном случае за '''C''' возьмем любой из листовых потомков.

Если '''M''' является красным узлом, заменим его своим потомком '''C''', который по определению должен быть чёрным. (Это может произойти только тогда, когда '''M''' имеет двух листовых потомков, потому что если красный узел '''M''' имеет чёрного нелистового потомка с одной стороны, а с другой стороны — листового, то число чёрных узлов на обеих сторонах будет различным, таким образом дерево станет недействительным красно-чёрным деревом из-за нарушения Свойства 5.) Все пути через удаляемый узел просто будут содержать на один красный узел меньше, предок и потомок удаляемого узла должны быть чёрными, так что Свойство 3 («Все листья — чёрные») и Свойство 4 («Оба потомка красного узла — чёрные») все ещё сохраняется.

Другим простым является случай, когда '''M''' — чёрный и '''C''' — красный. Простое удаление чёрного узла нарушит Свойство 4 («Оба потомка красного узла — чёрные») и Свойство 5 («Всякий простой путь от данного узла до любого листового узла, содержит одинаковое число чёрных узлов»), но если мы перекрасим '''С''' в чёрный, оба эти свойства сохранятся.

Сложным является случай, когда и '''M''' и '''C''' — чёрные. (Это может произойти только тогда, когда удаляется чёрный узел, который имеет два листовых потомка, потому что если чёрный узел '''M''' имеет чёрного нелистового потомка с одной стороны, а с другой — листового, то число чёрных узлов на обеих сторонах будет различным и дерево станет недействительным красно-чёрным деревом из-за нарушения Свойства 5.)
Мы начнём с замены узла '''M''' своим потомком '''C'''. Будем называть этого потомка (в своем новом положении) '''N''', а его «брата» (другого потомка его нового предка) — '''S'''. (До этого '''S''' был «братом» '''M'''.)
На рисунках ниже мы также будем использовать обозначение '''P''' для нового предка '''N''' (старого предка '''M'''), '''S<sub>L</sub>''' для левого потомка '''S''' и '''S<sub>R</sub>''' для правого потомка '''S''' ('''S''' не может быть листовым узлом, так как если '''N''' по нашему предположению является чёрным, то поддерево '''P''', которое содержит '''N''', чёрной высоты два и поэтому другое поддерево '''P''', которое содержит '''S''' должно быть также чёрной высоты два, что не может быть в случае, когда '''S''' — лист).

: ''Примечание'': В некоторых случаях мы меняем роли и обозначения узлов, но в каждом случае любое обозначение продолжает означать тот же узел, что и в начале случая. Любые цвета, изображенные на рисунке либо предполагаются случаем, либо получается из других предположений. Белый означает неизвестный цвет (либо красный, либо чёрный).

Будем искать «брата», используя эту функцию:

<source lang="c">
struct node *
sibling(struct node *n)
{
	if (n == n->parent->left)
		return n->parent->right;
	else
		return n->parent->left;
}
</source>

: ''Примечание'': Для того, чтобы дерево оставалось верно определенным, нам нужно, чтобы каждый лист оставался листом после всех преобразований (чтобы у него не было потомков). Если удаляемый нами узел имеет нелистового потомка '''N''', легко видеть, что свойство выполняется. С другой стороны, если '''N''' — лист, то, как можно увидеть из рисунков или кода, свойство также выполняется.

Мы можем выполнить действия, описанные выше, используя следующий код, где функция <code>replace_node</code> ставит <code>child</code> на место узла <code>n</code> в дереве. Для удобства, код в этом разделе предполагает, что нулевые листья представлены реальными объектами узла, а не NULL (код вставки должен работать с таким же представлением).

<source lang="c">
void 
replace_node(node* n, node* child) {
    child->parent = n->parent;
    if (n == n->parent->left) {
        n->parent->left = child;
    } else {
        n->parent->right = child;
    }
}

void
delete_one_child(struct node *n)
{
	/*
	 * Условие: n имеет не более одного ненулевого потомка.
	 */
	struct node *child = is_leaf(n->right) ? n->left : n->right;
    
	replace_node(n, child);
	if (n->color == BLACK) {
		if (child->color == RED)
			child->color = BLACK;
		else
			delete_case1(child);
	}
	free(n);
}
</source>

: ''Примечание'': Если '''N''' является нулевым листом и мы не хотим представлять нулевые листы как реальные объекты, мы можем изменить алгоритм сначала вызывая delete_case1() на его отца (узел, который мы удалили, <code>n</code> в коде выше) и удаляя его после этого. Мы можем сделать это потому, что отец чёрный, и поэтому ведет себя так же как нулевой лист (и иногда называется 'phantom' лист). Мы можем безопасно удалить его так как <code>n</code> останется листом после всех операций, как показано выше.

Если '''N''' и его текущий отец чёрные, тогда удаление отца приведет к тому, что пути, которые проходят через '''N''' будут иметь на один чёрный узел меньше, чем пути, которые не проходят через него. Так как это нарушает свойство 5 (все пути из любого узла к его листовым узлам содержат одинаковое количество чёрных узлов), дерево должно быть перебалансировано. Есть несколько случаев для рассмотрения:

'''Случай 1:''' '''N''' — новый корень. В этом случае, все сделано. Мы удалили один чёрный узел из каждого пути и новый корень является чёрным узлом, так что свойства сохранены.

<source lang="c">
void
delete_case1(struct node *n)
{
	if (n->parent != NULL)
		delete_case2(n);
}
</source>

: ''Примечание'': В случаях 2, 5, и 6 мы предполагаем, что '''N''' является левым потомком своего предка '''P'''. Если он — правый потомок, ''left'' и ''right'' нужно поменять местами во всех трех случаях. Опять-таки, примеры кода принимают это во внимание.

{|
|[[Файл:Red-black tree delete case 2 as svg.svg|справа|367x367пкс|Диаграмма случая 2]]'''Случай 2:''' '''S''' — красный. В этом случае мы меняем цвета '''P''' и '''S''', и затем делаем [[tree rotation|вращение]] влево вокруг '''P''', ставя '''S''' дедушкой '''N'''. Нужно заметить, что '''P''' должен быть чёрным, если он имеет красного потомка. Результирующее поддерево всё равно имеет черных узлов на единицу меньше, поэтому на этом мы ещё не закончили. Теперь '''N''' имеет чёрного брата и красного отца, поэтому мы можем перейти к шагу 4, 5 или 6. (Его новый брат является чёрным потому, что он был потомком красного '''S'''.)
Далее через '''S''' будет обозначен новый брат '''N'''.
|}

<source lang="c">
void delete_case2(struct node *n)
{
	struct node *s = sibling(n);

	if (s->color == RED) {
		n->parent->color = RED;
		s->color = BLACK;
		if (n == n->parent->left)
			rotate_left(n->parent);
		else
			rotate_right(n->parent);
	} 
	delete_case3(n);
}
</source>

{|
|[[Файл:Red-black tree delete case 3.png|left|Диаграмма случая 3]]
'''Случай 3:''' '''P''', '''S''', и дети '''S'''' — чёрные. В этом случае мы просто перекрашиваем '''S''' в красный. В результате все пути, проходящие через '''S''', но не проходящие через '''N''', имеют на один чёрный узел меньше. Так как удаление отца '''N''' приводит к тому, что все пути, проходящие через '''N''', содержат на один чёрный узел меньше, то такие действия выравнивают баланс. Тем не менее, все проходящие через '''P''' пути теперь содержат на один чёрный узел меньше, чем пути, которые через '''P''' не проходят, поэтому свойство 5 (все пути из любой вершины к её листовым узлам содержат одинаковое количество чёрных узлов) все ещё нарушено. Чтобы это исправить, мы применяем процедуру перебалансировки к '''P''', начиная со случая 1.
|}

<source lang="c">
void delete_case3(struct node *n)
{
	struct node *s = sibling(n);

	if (
            (n->parent->color == BLACK) &&
	        (s->color == BLACK) &&
	        (s->left->color == BLACK) &&
	        (s->right->color == BLACK)
        )
    {
		s->color = RED;
		delete_case1(n->parent);
	} else
		delete_case4(n);
}
</source>

{|
|[[Файл:Red-black tree delete case 4.png|right|Диаграмма случая 4]]
'''Случай 4:''' '''S''' и его дети — чёрные, но '''P''' — красный. В этом случае мы просто меняем цвета '''S''' и '''P'''. Это не влияет на количество чёрных узлов на путях, проходящих через '''S''', но добавит один к числу чёрных узлов на путях, проходящих через '''N''', восстанавливая тем самым влияние удаленного чёрного узла.
|}

<source lang="c">
void delete_case4(struct node *n)
{
	struct node *s = sibling(n);

	if (
            (n->parent->color == RED) &&
	        (s->color == BLACK) &&
	        (s->left->color == BLACK) &&
	        (s->right->color == BLACK)
        )
    {
		s->color = RED;
		n->parent->color = BLACK;
	} else
		delete_case5(n);
}
</source>

{|
|[[Файл:Red-black tree delete case 5.png|left|Диаграмма случая 5]]
'''Случай 5:''' '''S''' — чёрный, левый потомок '''S''' — красный, правый потомок '''S''' — чёрный, и '''N''' является левым потомков своего отца. В этом случае мы вращаем дерево вправо вокруг '''S'''. Таким образом левый потомок '''S''' становится его отцом и новым братом '''N'''. После этого мы меняем цвета у '''S''' и его нового отца.
Все пути по-прежнему содержат одинаковое количество чёрных узлов, но теперь у '''N''' есть чёрный брат с красным правым потомком, и мы переходим к случаю 6. Ни '''N''', ни его отец не влияют на эту трансформацию.
(Для случая 6 мы обозначим через '''S''' нового брата '''N'''.)
|}

<source lang="c">
void delete_case5(struct node *n)
{
	struct node *s = sibling(n);

	if  (s->color == BLACK) { /* this if statement is trivial, 
due to case 2 (even though case 2 changed the sibling to a sibling's child, 
the sibling's child can't be red, since no red parent can have a red child). */
/* the following statements just force the red to be on the left of the left of the parent, 
   or right of the right, so case six will rotate correctly. */
		if (
                (n == n->parent->left) &&
		        (s->right->color == BLACK) &&
		        (s->left->color == RED)
           )
        {
            /* this last test is trivial too due to cases 2-4. */
			s->color = RED;
			s->left->color = BLACK;
			rotate_right(s);
		} else if (
                (n == n->parent->right) &&
		        (s->left->color == BLACK) &&
		        (s->right->color == RED)
            ) 
        {
            /* this last test is trivial too due to cases 2-4. */
			s->color = RED;
			s->right->color = BLACK;
			rotate_left(s);
		}
	}
	delete_case6(n);
}
</source>

{|
|[[Файл:Red-black tree delete case 6.png|right|Диаграмма случая 6]]
'''Случай 6:''' '''S''' — чёрный, правый потомок '''S''' — красный, и '''N''' является левым потомком своего отца '''P'''. В этом случае мы вращаем дерево влево вокруг '''P''', после чего '''S''' становится отцом '''P''' и своего правого потомка. Далее мы меняем местами цвета у '''P''' и '''S''' ('''P''' принимает цвет '''S''', '''S''' принимает цвет '''P'''), и делаем правого потомка '''S''' чёрным. Поддерево по-прежнему имеет тот же цвет корня, поэтому свойства 4 (Оба потомка каждого красного узла — чёрные) и 5 (все пути из любой вершины к её листовым узлам содержат одинаковое количество чёрных узлов) не нарушаются. Тем не менее, у '''N''' теперь появился дополнительный чёрный предок: либо '''P''' стал чёрным, или он был чёрным и '''S''' был добавлен в качестве чёрного дедушки. Таким образом, проходящие через '''N''' пути проходят через один дополнительный чёрный узел.

Между тем, если путь не проходит через '''N''', то есть 2 возможных варианта:
* Он проходит через нового брата '''N'''. Тогда, он должен проходить через '''S''' и '''P''', которые просто поменяли цвета и места. Поэтому путь содержит то же количество чёрных узлов.
* Он проходит через нового дядю '''N''', правого потомка '''S'''. Когда-то он проходил через '''S''', отца '''S''' и правого потомка '''S''' (который был красным), но теперь он проходит только через '''S''', который принял на себя цвет своего прежнего родителя, и правого потомка '''S''', который был перекрашен из красного в чёрный (Предполагаем, что цвет '''S''': чёрный). Эффект заключается в том, что этот путь проходит через такое же количество чёрных узлов.

В любом случае, число чёрных узлов на этих путях не изменится. Поэтому, мы восстановили свойства 4 (Оба потомка каждого красного узла — чёрные) и 5 (все пути из любой вершины к её листовым узлам содержат одинаковое количество чёрных узлов). Белый узел на диаграмме может быть как красным так и чёрным, но должен указывать на тот же цвет как в начале, так и в конце трансформации.
|}

<source lang="c">
void delete_case6(struct node *n)
{
	struct node *s = sibling(n);

	s->color = n->parent->color;
    n->parent->color = BLACK;

	if (n == n->parent->left) {
        s->right->color = BLACK;
		rotate_left(n->parent);
	} else {
		s->left->color = BLACK;
		rotate_right(n->parent);
	}
}
</source>

Все рекурсивные вызовы функции [[Хвостовая рекурсия|хвостовые]] и преобразуются в циклы, так что алгоритм [[:en:in-place algorithm|требует памяти O(1)]].
В алгоритме выше, все случаи связаны по очереди, кроме случая 3, где может произойти возврат к случаю 1, который применяется к предку узла: это единственный случай когда последовательная реализация будет эффективным циклом (после одного вращения в случае 3).

Так же, хвостовая рекурсия никогда не происходит на дочерних узлах, поэтому цикл хвостовой рекурсии может двигаться только от дочерних узлов к их последовательным родителям. Произойдет не более, чем O(log ''n'') циклических возвратов к случаю 1 (где ''n'' — общее количество узлов в дереве до удаления). Если в случае 2 произойдет вращение (единственно возможное в цикле случаев 1-3), тогда отец узла '''N''' становится красным после вращения и мы выходим из цикла. Таким образом будет произведено не более одного вращения в течение этого цикла. После выхода из цикла произойдет не более двух дополнительных поворотов. А в целом произойдет не более трех поворотов дерева.

== Сравнение со сбалансированным [[АВЛ-дерево]]м ==

=== Высота дерева ===
Пусть высота дерева h, минимальное количество вершин N. Тогда:
* для АВЛ-дерева <math>N(h)=N(h-1)+N(h-2)+1</math>. Поскольку <math>N(0)=0</math>, <math>N(1)=1</math>, N(h) растёт как [[последовательность Фибоначчи]], следовательно <math>N(h)=\Theta(\lambda^h)</math>, где <math>\lambda=(\sqrt{5}+1)/2\approx 1,62</math>
* для красно-чёрного дерева <math>N(h)\ge 2^{(h-1)/2} = \Theta(\sqrt{2}^h)</math>
Следовательно, при том же количестве листьев красно-чёрное дерево может быть выше АВЛ-дерева, но не более чем в <math>\log \lambda / \log \sqrt{2} \approx 1,388</math> раз.<ref>в пределе для большого числа листьев</ref>

=== Поиск ===
Поскольку красно-чёрное дерево, в худшем случае, выше, поиск в нём медленнее, но проигрыш по времени не превышает 39 %.

=== Вставка ===
Вставка требует до 2 поворотов в обоих видах деревьев. Однако из-за большей высоты красно-чёрного дерева вставка может занимать больше времени.

=== Удаление ===
Удаление из красно-чёрного дерева требует до 3 поворотов, в [[АВЛ-дерево|АВЛ-дереве]] оно может потребовать числа поворотов до глубины дерева (до корня). Поэтому удаление из красно-чёрного дерева быстрее, чем из АВЛ-дерева.
Тем не менее, тесты показывают, что АВЛ-деревья быстрее красно-чёрных во всех операциях<ref>[http://radius-server.livejournal.com/598.html AVL vs RB] {{Wayback|url=http://radius-server.livejournal.com/598.html |date=20160711043923 }}{{ref-en}}</ref><ref>[http://nathanbelue.blogspot.ru/2012/05/red-black-versus-avl.html Red-Black versus AVL: benchmarks] {{Wayback|url=http://nathanbelue.blogspot.ru/2012/05/red-black-versus-avl.html |date=20150210123801 }}{{ref-en}}</ref>, автор последнего теста предполагает, что красно-чёрные деревья, возможно, производительнее при больших объёмах памяти<ref>[http://nathanbelue.blogspot.ru/2013/01/avl-vs-red-black-conclusion_6.html AVL vs. Red-Black: the conclusion] {{Wayback|url=http://nathanbelue.blogspot.ru/2013/01/avl-vs-red-black-conclusion_6.html |date=20150210123740 }}{{ref-en}}</ref>.

=== Память ===
АВЛ-дерево в каждом узле хранит разницу высот (целое число от −1 до +1, для кодирования нужно 2 бита). Красно-чёрное дерево в каждом узле хранит цвет (1 бит). Таким образом, красно-чёрное дерево может быть экономичнее. (Правда если учитывать, что в современных вычислительных системах память выделяется кратно байтам, то деревья абсолютно одинаковы)

Однако, на практике в обоих типах деревьев используются целые числа, так как работа с битами требует дополнительных процессорных вычислений (одной команды ассемблера and %al 0x10000000). Но тем не менее есть реализации красно-чёрного дерева, которые хранят значение цвета в бите. Пример — [http://www.boost.org/doc/libs/1_48_0/libs/multi_index/doc/tutorial/index.html Boost Multiindex]. Цель хранения цвета в бите — уменьшение потребления памяти красно-чёрным деревом ([http://www.boost.org/doc/libs/1_48_0/libs/multi_index/doc/tutorial/indices.html#ordered_node_compression Ordered indices node compression]). Бит цвета в такой реализации хранится не в отдельной переменной, а в одном из указателей узла дерева с превращением его в [[:en:Tagged pointer|меченый указатель]].

== Доказательство асимптотических границ ==
Красно-чёрное дерево, которое содержит ''n'' внутренних узлов, имеет высоту <math>O(log(n))</math>.

Обозначения:

* <math>h(v)</math> — высота поддерева с корнем в <math>v</math>
* <math>bh(v)</math> — число чёрных узлов (не считая <math>v</math>, если он чёрный) от <math>v</math> до любого листа в поддереве (называемое чёрной высотой)

'''Лемма:''' Поддерево с корнем в узле <math>v</math> имеет не менее <math>2^{bh(v)}-1</math> внутренних узлов.

Доказательство леммы (индукцией по высоте):

Основание индукции: <math>h(v) = 0</math>.

Если поддерево имеет нулевую высоту, то <math>v</math> должен быть ''null'', поэтому <math>bh(''v'') = 0</math>.

Итак:

: <math>2^{bh(v)}-1 = 2^{0}-1 = 1-1 = 0
</math>

Индукционный шаг: пусть узел <math>v</math> такой, что <math>h(v) = k</math> и поддерево имеет не менее <math>2^{bh(v)}-1</math> внутренних узлов. <br>
Покажем, что тогда <math>v'</math>, для которого <math>h(v') = k+1</math>, имеет не менее <math>2^{bh(v')}-1</math> внутренних узлов.

Так как <math>v'</math> имеет <math>h(v') > 0</math>, это внутренний узел. Как таковой он имеет два потомка, оба из которых имеют чёрную высоту <math>bh(v')</math>, либо <math>bh(v')-1</math> (зависит от того, является <math>v'</math> красным, или чёрным). <br>
По индукционному предположению каждый потомок имеет не менее <math>2^{bh(v')-1}-1</math> внутренних узлов, поэтому <math>v'</math> имеет не менее

: <math>2^{bh(v') - 1} - 1 + 2^{bh(v') - 1} - 1 + 1 = 2^{bh(v')} - 1
</math>

внутренних узлов.

Используя эту лемму, мы можем показать, что дерево имеет логарифмическую высоту. Так как по крайней мере половина узлов в любом пути от корня до листа — чёрные (свойство 4 красно-чёрного дерева), чёрная высота корня не менее <math>h(root)/2</math>. По лемме имеем:

: <math>
n \geq 2^{{h(\text{root}) \over 2}} - 1 \leftrightarrow \; \log_2{(n+1)} \geq {h(\text{root}) \over 2} \leftrightarrow \; h(\text{root}) \leq 2\log_2{(n+1)}.
</math>

Поэтому высота корня <math>O(log(n))</math>.

== См. также ==
* [[Поиск в глубину]]
* [[Поиск в ширину]]
* Сбалансированные (самобалансирующиеся) деревья:
** [[АВЛ-дерево]]
** [[Матричное дерево]]
** [[Идеально сбалансированное дерево]]
** [[Расширяющееся дерево]]
** [[B+-деревья]]
** [[2-3-дерево]]
** [[R-дерево (структура данных)|R-дерево]]
** [[B*-дерево]]
* [[Проект:Информационные технологии/Списки/Список структур данных#Trees|Список структур данных (деревья)]]

== Ссылки ==
* [https://web.archive.org/web/20160304094827/http://cs.mipt.ru/docs/comp/rus/programming/algorithms/niman_sort_poisk/main.pdf Томас Ниман Сортировка и поиск: Рецептурный справочник]
* [https://web.archive.org/web/20070927222509/http://eternallyconfuzzled.com/tuts/datastructures/jsw_tut_rbtree.aspx Эффективная реализация красно-чёрных деревьев (ENG)]
* [http://algolist.manual.ru/ds/rbtree.php Красно-чёрные деревья (теория и реализация)]

== Литература ==
* {{книга
|автор = Кормен Т., Лейзерсон Ч., Ривест Р., Штайн К.
|заглавие = Алгоритмы: построение и анализ
|оригинал = Introduction to algorithms
|ссылка = https://archive.org/details/introductiontoal0000unse_h3k5/page/336
|издание = 2-е изд
|место =  М.
|издательство = [[Вильямс (издательство)|Издательский дом «Вильямс»]]
|год = 2011
|страницы = 336-364
|isbn = 978-5-8459-0857-5
}}

== Примечания ==
{{примечания}}

{{Деревья (структуры данных)}}

[[Категория:Деревья (структуры данных)]]