deploy

ru/chapter_appendix/installation/index.html

@@ -4913,7 +4913,7 @@
 </ol>
 <h3 id="4-c">4. &nbsp; Среда C<a class="headerlink" href="#4-c" title="Permanent link">&para;</a></h3>
 <ol>
-<li>Загрузите и установите <a href="https://dotnet.microsoft.com/en-us/download">.Net 8.0</a>.</li>
+<li>Загрузите и установите <a href="https://dotnet.microsoft.com/en-us/download">.NET 8.0</a>.</li>
 <li>В магазине расширений VS Code найдите <code>C# Dev Kit</code> и установите C# Dev Kit (<a href="https://code.visualstudio.com/docs/csharp/get-started">руководство по настройке</a>).</li>
 <li>Также можно использовать Visual Studio (<a href="https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022">руководство по установке</a>).</li>
 </ol>

ru/chapter_array_and_linkedlist/linked_list/index.html

@@ -4959,7 +4959,7 @@
 <a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="c1">// Конструктор</span>
 <a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="kd">class</span><span class="w"> </span><span class="nc">ListNode</span><span class="p">(</span><span class="n">x</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">_val</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w">          </span><span class="c1">// Значение узла</span>
-<a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">next</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w"> </span><span class="c1">// Ссылка на следующий узел</span>
+<a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">next</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w"> </span><span class="c1">// Ссылка на следующий узел</span>
 <a id="__codelineno-11-6" name="__codelineno-11-6" href="#__codelineno-11-6"></a><span class="p">}</span>
 </code></pre></div>
 </div>
@@ -6086,8 +6086,8 @@
 <a id="__codelineno-89-2" name="__codelineno-89-2" href="#__codelineno-89-2"></a><span class="c1">// Конструктор</span>
 <a id="__codelineno-89-3" name="__codelineno-89-3" href="#__codelineno-89-3"></a><span class="kd">class</span><span class="w"> </span><span class="nc">ListNode</span><span class="p">(</span><span class="n">x</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-89-4" name="__codelineno-89-4" href="#__codelineno-89-4"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">_val</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="w">           </span><span class="c1">// Значение узла</span>
-<a id="__codelineno-89-5" name="__codelineno-89-5" href="#__codelineno-89-5"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">next</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на следующий узел</span>
-<a id="__codelineno-89-6" name="__codelineno-89-6" href="#__codelineno-89-6"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">prev</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на предыдущий узел</span>
+<a id="__codelineno-89-5" name="__codelineno-89-5" href="#__codelineno-89-5"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">next</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на следующий узел</span>
+<a id="__codelineno-89-6" name="__codelineno-89-6" href="#__codelineno-89-6"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">prev</span><span class="p">:</span><span class="w"> </span><span class="n">ListNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на предыдущий узел</span>
 <a id="__codelineno-89-7" name="__codelineno-89-7" href="#__codelineno-89-7"></a><span class="p">}</span>
 </code></pre></div>
 </div>

ru/chapter_backtracking/permutations_problem/index.html

@@ -4828,7 +4828,7 @@
 <h3 id="1">1. &nbsp; Обрезка повторного выбора<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
 <p>Чтобы гарантировать, что каждый элемент выбирается только один раз, введем булев массив <code>selected</code> , где <code>selected[i]</code> обозначает, был ли уже выбран <code>choices[i]</code> , и на его основе выполним следующую обрезку.</p>
 <ul>
-<li>После того как сделан выбор <code>choice[i]</code> , мы присваиваем <code>selected[i]</code> значение <span class="arithmatex">\(\text{True}\)</span> , тем самым отмечая, что этот элемент уже выбран.</li>
+<li>После того как сделан выбор <code>choices[i]</code> , мы присваиваем <code>selected[i]</code> значение <span class="arithmatex">\(\text{True}\)</span> , тем самым отмечая, что этот элемент уже выбран.</li>
 <li>При обходе списка вариантов <code>choices</code> пропускаем все уже выбранные элементы, то есть выполняем обрезку.</li>
 </ul>
 <p>Как показано на рисунке 13-6, если в первом раунде мы выберем 1 , во втором - 3 , а в третьем - 2 , то во втором раунде нужно отсечь ветвь элемента 1 , а в третьем - ветви элементов 1 и 3 .</p>

ru/chapter_data_structure/number_encoding/index.html

@@ -4672,8 +4672,8 @@
 <div class="arithmatex">\[
 \begin{aligned}
 &amp; 1 + (-2) \newline
-&amp; \rightarrow 0000 \. 0001 + 1000 \. 0010 \newline
-&amp; = 1000 \. 0011 \newline
+&amp; \rightarrow 0000 \; 0001 + 1000 \; 0010 \newline
+&amp; = 1000 \; 0011 \newline
 &amp; \rightarrow -3
 \end{aligned}
 \]</div>
@@ -4681,38 +4681,38 @@
 <div class="arithmatex">\[
 \begin{aligned}
 &amp; 1 + (-2) \newline
-&amp; \rightarrow 0000 \. 0001 \. \text{(прямой код)} + 1000 \. 0010 \. \text{(прямой код)} \newline
-&amp; = 0000 \. 0001 \. \text{(обратный код)} + 1111  \. 1101 \. \text{(обратный код)} \newline
-&amp; = 1111 \. 1110 \. \text{(обратный код)} \newline
-&amp; = 1000 \. 0001 \. \text{(прямой код)} \newline
+&amp; \rightarrow 0000 \; 0001 \; \text{(прямой код)} + 1000 \; 0010 \; \text{(прямой код)} \newline
+&amp; = 0000 \; 0001 \; \text{(обратный код)} + 1111  \; 1101 \; \text{(обратный код)} \newline
+&amp; = 1111 \; 1110 \; \text{(обратный код)} \newline
+&amp; = 1000 \; 0001 \; \text{(прямой код)} \newline
 &amp; \rightarrow -1
 \end{aligned}
 \]</div>
 <p>С другой стороны, **в прямом коде у нуля есть два представления: <span class="arithmatex">\(+0\)</span> и <span class="arithmatex">\(-0\)</span> **. Это означает, что числу ноль соответствуют два разных двоичных кода, что может приводить к неоднозначности. Например, если в условном выражении не различать положительный и отрицательный ноль, можно получить ошибочный результат. А если специально обрабатывать такую неоднозначность, придется вводить дополнительные проверки, что может снизить вычислительную эффективность компьютера.</p>
 <div class="arithmatex">\[
 \begin{aligned}
-+0 &amp; \rightarrow 0000 \. 0000 \newline
--0 &amp; \rightarrow 1000 \. 0000
++0 &amp; \rightarrow 0000 \; 0000 \newline
+-0 &amp; \rightarrow 1000 \; 0000
 \end{aligned}
 \]</div>
 <p>Как и прямой код, обратный код тоже страдает от неоднозначности положительного и отрицательного нуля, поэтому компьютеры ввели <u>дополнительный код (2's complement)</u>. Сначала посмотрим на процесс преобразования отрицательного нуля из прямого кода в обратный, а затем в дополнительный:</p>
 <div class="arithmatex">\[
 \begin{aligned}
--0 \rightarrow \. &amp; 1000 \. 0000 \. \text{(прямой код)} \newline
-= \. &amp; 1111 \. 1111 \. \text{(обратный код)} \newline
-= 1 \. &amp; 0000 \. 0000 \. \text{(дополнительный код)} \newline
+-0 \rightarrow \; &amp; 1000 \; 0000 \; \text{(прямой код)} \newline
+= \; &amp; 1111 \; 1111 \; \text{(обратный код)} \newline
+= 1 \; &amp; 0000 \; 0000 \; \text{(дополнительный код)} \newline
 \end{aligned}
 \]</div>
-<p>При добавлении <span class="arithmatex">\(1\)</span> к обратному коду отрицательного нуля возникает перенос, но длина типа <code>byte</code> составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, <strong>дополнительный код отрицательного нуля равен <span class="arithmatex">\(0000 \. 0000\)</span> и совпадает с дополнительным кодом положительного нуля</strong>. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.</p>
+<p>При добавлении <span class="arithmatex">\(1\)</span> к обратному коду отрицательного нуля возникает перенос, но длина типа <code>byte</code> составляет всего 8 бит, поэтому переполнившаяся в 9-й бит единица отбрасывается. Иными словами, <strong>дополнительный код отрицательного нуля равен <span class="arithmatex">\(0000 \; 0000\)</span> и совпадает с дополнительным кодом положительного нуля</strong>. Значит, в представлении дополнительного кода существует только один ноль, и проблема неоднозначности положительного и отрицательного нуля тем самым устраняется.</p>
 <p>Остается последний вопрос: диапазон типа <code>byte</code> равен <span class="arithmatex">\([-128, 127]\)</span> , откуда берется лишнее отрицательное число <span class="arithmatex">\(-128\)</span> ? Мы замечаем, что у всех целых чисел из интервала <span class="arithmatex">\([-127, +127]\)</span> есть соответствующие прямой, обратный и дополнительный коды, а прямой и дополнительный коды можно преобразовывать друг в друга.</p>
-<p>Однако <strong>дополнительный код <span class="arithmatex">\(1000 \. 0000\)</span> является исключением: у него нет соответствующего прямого кода</strong>. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен <span class="arithmatex">\(0000 \. 0000\)</span> . Это очевидное противоречие, потому что такой прямой код обозначает число <span class="arithmatex">\(0\)</span> , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код <span class="arithmatex">\(1000 \. 0000\)</span> представляет число <span class="arithmatex">\(-128\)</span> . На самом деле результат вычисления <span class="arithmatex">\((-1) + (-127)\)</span> в дополнительном коде как раз и равен <span class="arithmatex">\(-128\)</span> .</p>
+<p>Однако <strong>дополнительный код <span class="arithmatex">\(1000 \; 0000\)</span> является исключением: у него нет соответствующего прямого кода</strong>. Согласно правилу преобразования, прямой код для этого дополнительного кода должен быть равен <span class="arithmatex">\(0000 \; 0000\)</span> . Это очевидное противоречие, потому что такой прямой код обозначает число <span class="arithmatex">\(0\)</span> , а его дополнительный код должен совпадать с ним самим. Компьютер просто определяет, что этот особый дополнительный код <span class="arithmatex">\(1000 \; 0000\)</span> представляет число <span class="arithmatex">\(-128\)</span> . На самом деле результат вычисления <span class="arithmatex">\((-1) + (-127)\)</span> в дополнительном коде как раз и равен <span class="arithmatex">\(-128\)</span> .</p>
 <div class="arithmatex">\[
 \begin{aligned}
 &amp; (-127) + (-1) \newline
-&amp; \rightarrow 1111 \. 1111 \. \text{(прямой код)} + 1000 \. 0001 \. \text{(прямой код)} \newline
-&amp; = 1000 \. 0000 \. \text{(обратный код)} + 1111  \. 1110 \. \text{(обратный код)} \newline
-&amp; = 1000 \. 0001 \. \text{(дополнительный код)} + 1111  \. 1111 \. \text{(дополнительный код)} \newline
-&amp; = 1000 \. 0000 \. \text{(дополнительный код)} \newline
+&amp; \rightarrow 1111 \; 1111 \; \text{(прямой код)} + 1000 \; 0001 \; \text{(прямой код)} \newline
+&amp; = 1000 \; 0000 \; \text{(обратный код)} + 1111  \; 1110 \; \text{(обратный код)} \newline
+&amp; = 1000 \; 0001 \; \text{(дополнительный код)} + 1111  \; 1111 \; \text{(дополнительный код)} \newline
+&amp; = 1000 \; 0000 \; \text{(дополнительный код)} \newline
 &amp; \rightarrow -128
 \end{aligned}
 \]</div>

ru/chapter_data_structure/summary/index.html

@@ -4662,7 +4662,7 @@
 <li>Прямой код, обратный код и дополнительный код - это три способа кодирования чисел в компьютере, между которыми можно выполнять взаимные преобразования. В прямом коде старший бит целого числа является знаковым, а остальные биты представляют значение числа.</li>
 <li>Целые числа в компьютере хранятся в виде дополнительного кода. В таком представлении компьютер может одинаково обрабатывать сложение положительных и отрицательных чисел без специальной аппаратной схемы для вычитания, и при этом исчезает неоднозначность положительного и отрицательного нуля.</li>
 <li>Кодирование числа с плавающей точкой состоит из 1 бита знака, 8 битов экспоненты и 23 битов мантиссы. Благодаря наличию экспоненты диапазон значений у чисел с плавающей точкой намного больше, чем у целых, но это достигается ценой потери точности.</li>
-<li>ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 127 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.</li>
+<li>ASCII - это самый ранний набор английских символов длиной 1 байт, включающий в общей сложности 128 символов. Набор GBK - распространенный китайский набор символов, включающий более двадцати тысяч иероглифов. Unicode стремится предоставить единый полный стандарт набора символов, включающий символы всех языков мира, чтобы решить проблемы искаженного текста, вызванные несовместимыми способами кодирования.</li>
 <li>UTF-8 - самый популярный способ кодирования Unicode, обладающий очень хорошей универсальностью. Это кодировка переменной длины, хорошо расширяемая и эффективно использующая память. UTF-16 и UTF-32 относятся к кодировкам фиксированной длины. При кодировании китайского текста UTF-16 занимает меньше места, чем UTF-8. Такие языки программирования, как Java и C#, по умолчанию используют UTF-16.</li>
 </ul>
 <h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>

ru/chapter_dynamic_programming/edit_distance_problem/index.html

@@ -4700,7 +4700,7 @@
 </ul>
 <p>Иначе говоря, каждый шаг решения, то есть операция редактирования над строкой <span class="arithmatex">\(s\)</span> , меняет те символы, которые еще необходимо сопоставить в строках <span class="arithmatex">\(s\)</span> и <span class="arithmatex">\(t\)</span> . Поэтому состояние определяется текущими позициями рассматриваемых символов в <span class="arithmatex">\(s\)</span> и <span class="arithmatex">\(t\)</span> , то есть состоянием <span class="arithmatex">\([i, j]\)</span> .</p>
 <p>Подзадача, соответствующая состоянию <span class="arithmatex">\([i, j]\)</span> , такова: <strong>минимальное число операций редактирования, необходимое для преобразования первых <span class="arithmatex">\(i\)</span> символов строки <span class="arithmatex">\(s\)</span> в первые <span class="arithmatex">\(j\)</span> символов строки <span class="arithmatex">\(t\)</span></strong>.</p>
-<p>Отсюда получается двумерная таблица <span class="arithmatex">\(dp\)</span> размера <span class="arithmatex">\((i+1) \times (j+1)\)</span> .</p>
+<p>Отсюда получается двумерная таблица <span class="arithmatex">\(dp\)</span> размера <span class="arithmatex">\((n+1) \times (m+1)\)</span> .</p>
 <p><strong>Шаг 2: найти оптимальную подструктуру и на ее основе вывести уравнение перехода состояния</strong></p>
 <p>Рассмотрим подзадачу <span class="arithmatex">\(dp[i, j]\)</span> . Ее последние символы - это <span class="arithmatex">\(s[i-1]\)</span> и <span class="arithmatex">\(t[j-1]\)</span> . В зависимости от операции редактирования возможны три случая, показанные на рисунке 14-29.</p>
 <ol>

ru/chapter_dynamic_programming/knapsack_problem/index.html

@@ -5709,7 +5709,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
 <p align="center"> Рисунок 14-20 &nbsp; Процесс динамического программирования для задачи о рюкзаке 0-1 </p>
 
 <h3 id="4">4. &nbsp; Оптимизация пространства<a class="headerlink" href="#4" title="Permanent link">&para;</a></h3>
-<p>Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с <span class="arithmatex">\(O(n^2)\)</span> до <span class="arithmatex">\(O(n)\)</span> .</p>
+<p>Поскольку каждое состояние зависит только от состояния в предыдущей строке, можно использовать два массива, которые будут продвигаться вперед по очереди, и тем самым уменьшить пространственную сложность с <span class="arithmatex">\(O(n \times cap)\)</span> до <span class="arithmatex">\(O(cap)\)</span> .</p>
 <p>Если пойти дальше, можно спросить: можно ли оптимизировать память так, чтобы использовать только один массив? Наблюдение показывает, что каждое состояние зависит от клетки прямо сверху и клетки слева сверху. Предположим, что у нас есть только один массив, и в момент начала обхода строки <span class="arithmatex">\(i\)</span> он еще хранит состояния строки <span class="arithmatex">\(i-1\)</span> .</p>
 <ul>
 <li>Если обходить массив слева направо, то к моменту вычисления <span class="arithmatex">\(dp[i, j]\)</span> значения слева сверху <span class="arithmatex">\(dp[i-1, 1]\)</span> ~ <span class="arithmatex">\(dp[i-1, j-1]\)</span> могут уже быть перезаписаны, и правильный результат перехода состояния получить не удастся.</li>

ru/chapter_dynamic_programming/summary/index.html

@@ -4651,7 +4651,7 @@
 <p><strong>Задача о расстоянии редактирования</strong></p>
 <ul>
 <li>Расстояние редактирования (расстояние Левенштейна) используется для измерения сходства двух строк и определяется как минимальное число операций редактирования, необходимых для преобразования одной строки в другую. Допустимые операции - вставка, удаление и замена.</li>
-<li>В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых <span class="arithmatex">\(i\)</span> символов строки <span class="arithmatex">\(s\)</span> в первые <span class="arithmatex">\(j\)</span> символов строки <span class="arithmatex">\(t\)</span> . Если <span class="arithmatex">\(s[i] \ne t[j]\)</span> , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же <span class="arithmatex">\(s[i] = t[j]\)</span> , то редактировать текущий символ не нужно.</li>
+<li>В задаче о расстоянии редактирования состояние определяется как минимальное число шагов редактирования, необходимых для преобразования первых <span class="arithmatex">\(i\)</span> символов строки <span class="arithmatex">\(s\)</span> в первые <span class="arithmatex">\(j\)</span> символов строки <span class="arithmatex">\(t\)</span> . Если <span class="arithmatex">\(s[i-1] \ne t[j-1]\)</span> , то существуют три решения: вставка, удаление и замена, и каждому из них соответствует своя остаточная подзадача. На этой основе выводятся оптимальная подструктура и уравнение перехода состояния. Если же <span class="arithmatex">\(s[i-1] = t[j-1]\)</span> , то редактировать текущий символ не нужно.</li>
 <li>В задаче о расстоянии редактирования состояние зависит от значений сверху, слева и слева сверху. Поэтому после оптимизации памяти ни прямой, ни обратный обход сам по себе не дает корректного перехода состояния. Для решения этой проблемы значение слева сверху временно сохраняется в отдельной переменной, что делает ситуацию эквивалентной задаче о полном рюкзаке и позволяет использовать прямой обход.</li>
 </ul>
 

ru/chapter_greedy/greedy_algorithm/index.html

@@ -5055,7 +5055,7 @@
 <li><strong>Задача о дробном рюкзаке</strong>: дана группа предметов и грузоподъемность. Требуется выбрать предметы так, чтобы их общий вес не превышал ограничение, а общая ценность была максимальной. Если каждый раз выбирать предмет с наилучшим отношением стоимости к весу, то в некоторых случаях жадный алгоритм дает оптимальный ответ.</li>
 <li><strong>Задача о покупке и продаже акций</strong>: дана история цен акции. Можно совершать несколько сделок, но если акция уже куплена, то до продажи покупать снова нельзя. Цель - получить максимальную прибыль.</li>
 <li><strong>Код Хаффмана</strong>: это жадный алгоритм для сжатия данных без потерь. Построив дерево Хаффмана и каждый раз объединяя два узла с наименьшей частотой, мы получаем дерево с минимальной взвешенной длиной пути, то есть минимальной длиной кодирования.</li>
-<li><strong>Алгоритм Дейкстры</strong>: это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.</li>
+<li><strong>Алгоритм Дейкстры</strong>: для графов с неотрицательными весами ребер это жадный алгоритм решения задачи о кратчайших путях от заданной исходной вершины до всех остальных вершин.</li>
 </ul>
 
 <!-- Source file information -->

ru/chapter_greedy/max_product_cutting_problem/index.html

@@ -4715,7 +4715,7 @@ n & \geq 4
 <li>Для заданного целого <span class="arithmatex">\(n\)</span> непрерывно выделять из него множитель <span class="arithmatex">\(3\)</span>, пока остаток не станет равным <span class="arithmatex">\(0\)</span>, <span class="arithmatex">\(1\)</span> или <span class="arithmatex">\(2\)</span>.</li>
 <li>Если остаток равен <span class="arithmatex">\(0\)</span>, это означает, что <span class="arithmatex">\(n\)</span> кратно <span class="arithmatex">\(3\)</span>, и больше ничего делать не нужно.</li>
 <li>Если остаток равен <span class="arithmatex">\(2\)</span>, дальнейшее разбиение не требуется, его нужно сохранить.</li>
-<li>Если остаток равен <span class="arithmatex">\(1\)</span>, то поскольку <span class="arithmatex">\(2 \times 2 &gt; 1 \times 3\)</span>, последний множитель <span class="arithmatex">\(3\)</span> следует заменить на <span class="arithmatex">\(2\)</span>.</li>
+<li>Если остаток равен <span class="arithmatex">\(1\)</span>, то поскольку <span class="arithmatex">\(2 \times 2 &gt; 1 \times 3\)</span>, последний множитель <span class="arithmatex">\(3\)</span> и оставшуюся единицу следует заменить двумя множителями <span class="arithmatex">\(2\)</span>.</li>
 </ol>
 <h3 id="2">2. &nbsp; Код реализации<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
 <p>Как показано на рисунке 15-16, нам не нужен цикл, чтобы выполнять разбиение числа. Можно использовать целочисленное деление, чтобы получить число троек <span class="arithmatex">\(a\)</span>, и операцию взятия остатка, чтобы получить остаток <span class="arithmatex">\(b\)</span>. Тогда имеем:</p>

ru/chapter_hashing/summary/index.html

@@ -4662,7 +4662,7 @@
 <li>Коэффициент загрузки определяется как отношение числа элементов в хеш-таблице к числу бакетов, отражает степень серьезности хеш-коллизий и часто используется как условие запуска расширения хеш-таблицы.</li>
 <li>Метод цепочек превращает одиночный элемент в связный список и хранит все конфликтующие элементы в одном списке. Однако слишком длинный список снижает эффективность поиска, поэтому его можно дополнительно преобразовать в красно-черное дерево.</li>
 <li>Открытая адресация обрабатывает хеш-коллизии за счет многократного пробирования. Линейное пробирование использует фиксированный шаг, его недостатки - невозможность прямого удаления элементов и склонность к кластеризации. Повторное хеширование использует несколько хеш-функций и по сравнению с линейным пробированием меньше подвержено кластеризации, но требует больше вычислений.</li>
-<li>Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, <code>HashMap</code> в Java использует метод цепочек, а <code>Dict</code> в Python - открытую адресацию.</li>
+<li>Разные языки программирования выбирают разные стратегии реализации хеш-таблиц. Например, <code>HashMap</code> в Java использует метод цепочек, а <code>dict</code> в Python - открытую адресацию.</li>
 <li>Для хеш-таблицы желательно, чтобы хеш-алгоритм был детерминированным, быстрым и обеспечивал равномерное распределение. В криптографии от него дополнительно требуют устойчивости к коллизиям и эффекта лавины.</li>
 <li>В качестве модуля хеш-алгоритмы обычно используют большое простое число, чтобы максимально обеспечить равномерность распределения хеш-значений и снизить число хеш-коллизий.</li>
 <li>К распространенным хеш-алгоритмам относятся MD5, SHA-1, SHA-2 и SHA-3. MD5 часто применяли для проверки целостности файлов, а SHA-2 широко используется в протоколах и приложениях, связанных с безопасностью.</li>

ru/chapter_heap/build_heap/index.html

@@ -4969,7 +4969,7 @@
 <h2 id="823">8.2.3 &nbsp; Анализ сложности<a class="headerlink" href="#823" title="Permanent link">&para;</a></h2>
 <p>Теперь попробуем оценить временную сложность второго способа построения кучи.</p>
 <ul>
-<li>Пусть число узлов полного двоичного дерева равно <span class="arithmatex">\(n\)</span> , тогда число листовых узлов равно <span class="arithmatex">\((n + 1) / 2\)</span> , где <span class="arithmatex">\(/\)</span> означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно <span class="arithmatex">\((n - 1) / 2\)</span> .</li>
+<li>Пусть число узлов полного двоичного дерева равно <span class="arithmatex">\(n\)</span> , тогда число листовых узлов равно <span class="arithmatex">\((n + 1) / 2\)</span> , где <span class="arithmatex">\(/\)</span> означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно <span class="arithmatex">\(n / 2\)</span> .</li>
 <li>В процессе упорядочивания сверху вниз каждый узел в худшем случае может просеяться до листа, поэтому максимальное число итераций равно высоте двоичного дерева <span class="arithmatex">\(\log n\)</span> .</li>
 </ul>
 <p>Перемножив эти два значения, можно получить временную сложность построения кучи <span class="arithmatex">\(O(n \log n)\)</span> . <strong>Но эта оценка неточна, потому что мы не учли свойство двоичного дерева: на нижних уровнях узлов гораздо больше, чем на верхних</strong>.</p>

ru/chapter_searching/binary_search_insertion/index.html

@@ -4666,7 +4666,7 @@
 <p>По условию <code>target</code> нужно вставить слева от равного элемента, а это означает, что новый <code>target</code> занимает место старого <code>target</code> . Иначе говоря, <strong>если массив содержит <code>target</code> , то индекс вставки совпадает с индексом этого <code>target</code></strong>.</p>
 <p><strong>Вопрос 2</strong>: если массив не содержит <code>target</code> , индекс какого элемента будет точкой вставки?</p>
 <p>Рассмотрим процесс двоичного поиска подробнее: когда <code>nums[m] &lt; target</code> , указатель <span class="arithmatex">\(i\)</span> сдвигается вправо и тем самым приближается к элементу, который больше либо равен <code>target</code> . Аналогично указатель <span class="arithmatex">\(j\)</span> постепенно приближается к элементу, который меньше либо равен <code>target</code> .</p>
-<p>Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель <span class="arithmatex">\(i\)</span> указывает на первый элемент, больший <code>target</code> , а указатель <span class="arithmatex">\(j\)</span> указывает на первый элемент, меньший <code>target</code> . <strong>Нетрудно сделать вывод, что если массив не содержит <code>target</code> , то индекс вставки равен <span class="arithmatex">\(i\)</span></strong> . Код приведен ниже:</p>
+<p>Следовательно, после завершения двоичного поиска обязательно выполняется следующее: указатель <span class="arithmatex">\(i\)</span> указывает на первый элемент, больший <code>target</code> , а указатель <span class="arithmatex">\(j\)</span> указывает на самый правый элемент, меньший <code>target</code> . <strong>Нетрудно сделать вывод, что если массив не содержит <code>target</code> , то индекс вставки равен <span class="arithmatex">\(i\)</span></strong> . Код приведен ниже:</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:13"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><input id="__tabbed_1_13" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Kotlin</label><label for="__tabbed_1_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -4957,7 +4957,7 @@
 <li>Когда <code>nums[m] &lt; target</code> или <code>nums[m] &gt; target</code> , это означает, что <code>target</code> еще не найден, поэтому используется стандартная операция сужения интервала в двоичном поиске, <strong>благодаря чему указатели <span class="arithmatex">\(i\)</span> и <span class="arithmatex">\(j\)</span> приближаются к <code>target</code></strong>.</li>
 <li>Когда <code>nums[m] == target</code> , это означает, что элементы меньше <code>target</code> находятся в интервале <span class="arithmatex">\([i, m - 1]\)</span> , поэтому мы используем <span class="arithmatex">\(j = m - 1\)</span> для сужения интервала, <strong>тем самым приближая указатель <span class="arithmatex">\(j\)</span> к элементам, меньшим <code>target</code></strong>.</li>
 </ul>
-<p>После завершения цикла указатель <span class="arithmatex">\(i\)</span> будет указывать на самый левый <code>target</code> , а указатель <span class="arithmatex">\(j\)</span> - на первый элемент, меньший <code>target</code> , <strong>поэтому индекс <span class="arithmatex">\(i\)</span> и является точкой вставки</strong>.</p>
+<p>После завершения цикла указатель <span class="arithmatex">\(i\)</span> будет указывать на самый левый <code>target</code> , а указатель <span class="arithmatex">\(j\)</span> - на самый правый элемент, меньший <code>target</code> , <strong>поэтому индекс <span class="arithmatex">\(i\)</span> и является точкой вставки</strong>.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:8"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">&lt;1&gt;</label><label for="__tabbed_2_2">&lt;2&gt;</label><label for="__tabbed_2_3">&lt;3&gt;</label><label for="__tabbed_2_4">&lt;4&gt;</label><label for="__tabbed_2_5">&lt;5&gt;</label><label for="__tabbed_2_6">&lt;6&gt;</label><label for="__tabbed_2_7">&lt;7&gt;</label><label for="__tabbed_2_8">&lt;8&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -5003,7 +5003,7 @@
 <a id="__codelineno-13-8" name="__codelineno-13-8" href="#__codelineno-13-8"></a>        <span class="k">elif</span> <span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span> <span class="o">&gt;</span> <span class="n">target</span><span class="p">:</span>
 <a id="__codelineno-13-9" name="__codelineno-13-9" href="#__codelineno-13-9"></a>            <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span>  <span class="c1"># target находится в интервале [i, m-1]</span>
 <a id="__codelineno-13-10" name="__codelineno-13-10" href="#__codelineno-13-10"></a>        <span class="k">else</span><span class="p">:</span>
-<a id="__codelineno-13-11" name="__codelineno-13-11" href="#__codelineno-13-11"></a>            <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span>  <span class="c1"># Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-13-11" name="__codelineno-13-11" href="#__codelineno-13-11"></a>            <span class="n">j</span> <span class="o">=</span> <span class="n">m</span> <span class="o">-</span> <span class="mi">1</span>  <span class="c1"># Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-13-12" name="__codelineno-13-12" href="#__codelineno-13-12"></a>    <span class="c1"># Вернуть точку вставки i</span>
 <a id="__codelineno-13-13" name="__codelineno-13-13" href="#__codelineno-13-13"></a>    <span class="k">return</span> <span class="n">i</span>
 </code></pre></div>
@@ -5019,7 +5019,7 @@
 <a id="__codelineno-14-8" name="__codelineno-14-8" href="#__codelineno-14-8"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-14-9" name="__codelineno-14-9" href="#__codelineno-14-9"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-14-10" name="__codelineno-14-10" href="#__codelineno-14-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-14-11" name="__codelineno-14-11" href="#__codelineno-14-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-14-11" name="__codelineno-14-11" href="#__codelineno-14-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-14-12" name="__codelineno-14-12" href="#__codelineno-14-12"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-14-13" name="__codelineno-14-13" href="#__codelineno-14-13"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-14-14" name="__codelineno-14-14" href="#__codelineno-14-14"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5038,7 +5038,7 @@
 <a id="__codelineno-15-8" name="__codelineno-15-8" href="#__codelineno-15-8"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="o">[</span><span class="n">m</span><span class="o">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-15-9" name="__codelineno-15-9" href="#__codelineno-15-9"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-15-10" name="__codelineno-15-10" href="#__codelineno-15-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-15-11" name="__codelineno-15-11" href="#__codelineno-15-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-15-11" name="__codelineno-15-11" href="#__codelineno-15-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-15-12" name="__codelineno-15-12" href="#__codelineno-15-12"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-15-13" name="__codelineno-15-13" href="#__codelineno-15-13"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-15-14" name="__codelineno-15-14" href="#__codelineno-15-14"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5057,7 +5057,7 @@
 <a id="__codelineno-16-8" name="__codelineno-16-8" href="#__codelineno-16-8"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-16-9" name="__codelineno-16-9" href="#__codelineno-16-9"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-16-10" name="__codelineno-16-10" href="#__codelineno-16-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-16-11" name="__codelineno-16-11" href="#__codelineno-16-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-16-11" name="__codelineno-16-11" href="#__codelineno-16-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-16-12" name="__codelineno-16-12" href="#__codelineno-16-12"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-16-13" name="__codelineno-16-13" href="#__codelineno-16-13"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-16-14" name="__codelineno-16-14" href="#__codelineno-16-14"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5080,7 +5080,7 @@
 <a id="__codelineno-17-12" name="__codelineno-17-12" href="#__codelineno-17-12"></a><span class="w">            </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-17-13" name="__codelineno-17-13" href="#__codelineno-17-13"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span>
 <a id="__codelineno-17-14" name="__codelineno-17-14" href="#__codelineno-17-14"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-17-15" name="__codelineno-17-15" href="#__codelineno-17-15"></a><span class="w">            </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-17-15" name="__codelineno-17-15" href="#__codelineno-17-15"></a><span class="w">            </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-17-16" name="__codelineno-17-16" href="#__codelineno-17-16"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span>
 <a id="__codelineno-17-17" name="__codelineno-17-17" href="#__codelineno-17-17"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-17-18" name="__codelineno-17-18" href="#__codelineno-17-18"></a><span class="w">    </span><span class="p">}</span>
@@ -5102,7 +5102,7 @@
 <a id="__codelineno-18-10" name="__codelineno-18-10" href="#__codelineno-18-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-18-11" name="__codelineno-18-11" href="#__codelineno-18-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-18-12" name="__codelineno-18-12" href="#__codelineno-18-12"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-18-13" name="__codelineno-18-13" href="#__codelineno-18-13"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-18-13" name="__codelineno-18-13" href="#__codelineno-18-13"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-18-14" name="__codelineno-18-14" href="#__codelineno-18-14"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-18-15" name="__codelineno-18-15" href="#__codelineno-18-15"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-18-16" name="__codelineno-18-16" href="#__codelineno-18-16"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5122,7 +5122,7 @@
 <a id="__codelineno-19-9" name="__codelineno-19-9" href="#__codelineno-19-9"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="nx">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-19-10" name="__codelineno-19-10" href="#__codelineno-19-10"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-19-11" name="__codelineno-19-11" href="#__codelineno-19-11"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-19-12" name="__codelineno-19-12" href="#__codelineno-19-12"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-19-12" name="__codelineno-19-12" href="#__codelineno-19-12"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-19-13" name="__codelineno-19-13" href="#__codelineno-19-13"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-19-14" name="__codelineno-19-14" href="#__codelineno-19-14"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-19-15" name="__codelineno-19-15" href="#__codelineno-19-15"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5142,7 +5142,7 @@
 <a id="__codelineno-20-9" name="__codelineno-20-9" href="#__codelineno-20-9"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="nx">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-20-10" name="__codelineno-20-10" href="#__codelineno-20-10"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-20-11" name="__codelineno-20-11" href="#__codelineno-20-11"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-20-12" name="__codelineno-20-12" href="#__codelineno-20-12"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-20-12" name="__codelineno-20-12" href="#__codelineno-20-12"></a><span class="w">            </span><span class="nx">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nx">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mf">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-20-13" name="__codelineno-20-13" href="#__codelineno-20-13"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-20-14" name="__codelineno-20-14" href="#__codelineno-20-14"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-20-15" name="__codelineno-20-15" href="#__codelineno-20-15"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5161,7 +5161,7 @@
 <a id="__codelineno-21-8" name="__codelineno-21-8" href="#__codelineno-21-8"></a><span class="w">    </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-21-9" name="__codelineno-21-9" href="#__codelineno-21-9"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-21-10" name="__codelineno-21-10" href="#__codelineno-21-10"></a><span class="w">    </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-21-11" name="__codelineno-21-11" href="#__codelineno-21-11"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-21-11" name="__codelineno-21-11" href="#__codelineno-21-11"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-21-12" name="__codelineno-21-12" href="#__codelineno-21-12"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-21-13" name="__codelineno-21-13" href="#__codelineno-21-13"></a><span class="w">  </span><span class="p">}</span>
 <a id="__codelineno-21-14" name="__codelineno-21-14" href="#__codelineno-21-14"></a><span class="w">  </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5180,7 +5180,7 @@
 <a id="__codelineno-22-8" name="__codelineno-22-8" href="#__codelineno-22-8"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-22-9" name="__codelineno-22-9" href="#__codelineno-22-9"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-22-10" name="__codelineno-22-10" href="#__codelineno-22-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-22-11" name="__codelineno-22-11" href="#__codelineno-22-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-22-11" name="__codelineno-22-11" href="#__codelineno-22-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-22-12" name="__codelineno-22-12" href="#__codelineno-22-12"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-22-13" name="__codelineno-22-13" href="#__codelineno-22-13"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-22-14" name="__codelineno-22-14" href="#__codelineno-22-14"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5199,7 +5199,7 @@
 <a id="__codelineno-23-8" name="__codelineno-23-8" href="#__codelineno-23-8"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="p">[</span><span class="n">m</span><span class="p">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-23-9" name="__codelineno-23-9" href="#__codelineno-23-9"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-23-10" name="__codelineno-23-10" href="#__codelineno-23-10"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-23-11" name="__codelineno-23-11" href="#__codelineno-23-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-23-11" name="__codelineno-23-11" href="#__codelineno-23-11"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-23-12" name="__codelineno-23-12" href="#__codelineno-23-12"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-23-13" name="__codelineno-23-13" href="#__codelineno-23-13"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-23-14" name="__codelineno-23-14" href="#__codelineno-23-14"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5219,7 +5219,7 @@
 <a id="__codelineno-24-9" name="__codelineno-24-9" href="#__codelineno-24-9"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nums</span><span class="o">[</span><span class="n">m</span><span class="o">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
 <a id="__codelineno-24-10" name="__codelineno-24-10" href="#__codelineno-24-10"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="w"> </span><span class="c1">// target находится в интервале [i, m-1]</span>
 <a id="__codelineno-24-11" name="__codelineno-24-11" href="#__codelineno-24-11"></a><span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
-<a id="__codelineno-24-12" name="__codelineno-24-12" href="#__codelineno-24-12"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="w"> </span><span class="c1">// Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-24-12" name="__codelineno-24-12" href="#__codelineno-24-12"></a><span class="w">            </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="m">1</span><span class="w"> </span><span class="c1">// Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-24-13" name="__codelineno-24-13" href="#__codelineno-24-13"></a><span class="w">        </span><span class="p">}</span>
 <a id="__codelineno-24-14" name="__codelineno-24-14" href="#__codelineno-24-14"></a><span class="w">    </span><span class="p">}</span>
 <a id="__codelineno-24-15" name="__codelineno-24-15" href="#__codelineno-24-15"></a><span class="w">    </span><span class="c1">// Вернуть точку вставки i</span>
@@ -5242,7 +5242,7 @@
 <a id="__codelineno-25-12" name="__codelineno-25-12" href="#__codelineno-25-12"></a><span class="w">    </span><span class="k">elsif</span><span class="w"> </span><span class="n">nums</span><span class="o">[</span><span class="n">m</span><span class="o">]</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">target</span>
 <a id="__codelineno-25-13" name="__codelineno-25-13" href="#__codelineno-25-13"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1"># target находится в интервале [i, m-1]</span>
 <a id="__codelineno-25-14" name="__codelineno-25-14" href="#__codelineno-25-14"></a><span class="w">    </span><span class="k">else</span>
-<a id="__codelineno-25-15" name="__codelineno-25-15" href="#__codelineno-25-15"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1"># Первый элемент меньше target находится в интервале [i, m-1]</span>
+<a id="__codelineno-25-15" name="__codelineno-25-15" href="#__codelineno-25-15"></a><span class="w">      </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="c1"># Самый правый элемент, меньший target, находится в интервале [i, m-1]</span>
 <a id="__codelineno-25-16" name="__codelineno-25-16" href="#__codelineno-25-16"></a><span class="w">    </span><span class="k">end</span>
 <a id="__codelineno-25-17" name="__codelineno-25-17" href="#__codelineno-25-17"></a><span class="w">  </span><span class="k">end</span>
 <a id="__codelineno-25-18" name="__codelineno-25-18" href="#__codelineno-25-18"></a>

ru/chapter_sorting/bucket_sort/index.html

@@ -4674,7 +4674,7 @@
 
 <!-- Page content -->
 <h1 id="118">11.8 &nbsp; Блочная сортировка<a class="headerlink" href="#118" title="Permanent link">&para;</a></h1>
-<p>Рассмотренные выше алгоритмы сортировки относятся к «сортировкам на основе сравнений»: они упорядочивают данные, сравнивая элементы друг с другом. Временная сложность таких алгоритмов не может быть лучше <span class="arithmatex">\(O(n \log n)\)</span> . Далее мы рассмотрим несколько «сортировок без сравнений», чья временная сложность может достигать линейного порядка.</p>
+<p>Рассмотренные выше алгоритмы сортировки относятся к «сортировкам на основе сравнений»: они упорядочивают данные, сравнивая элементы друг с другом. Нижняя граница их временной сложности в худшем случае равна <span class="arithmatex">\(\Omega(n \log n)\)</span> . Далее мы рассмотрим несколько «сортировок без сравнений», чья временная сложность может достигать линейного порядка.</p>
 <p><u>Блочная сортировка (bucket sort)</u> является типичным применением стратегии «разделяй и властвуй». Она создает набор упорядоченных по величине блоков, где каждый блок соответствует определенному диапазону данных. Затем элементы равномерно распределяются по этим блокам, внутри каждого блока отдельно выполняется сортировка, а в конце результаты объединяются в порядке блоков.</p>
 <h2 id="1181">11.8.1 &nbsp; Алгоритм<a class="headerlink" href="#1181" title="Permanent link">&para;</a></h2>
 <p>Рассмотрим массив длины <span class="arithmatex">\(n\)</span>, элементы которого являются числами с плавающей запятой из диапазона <span class="arithmatex">\([0, 1)\)</span> . Процесс блочной сортировки показан на рисунке 11-13.</p>

ru/chapter_sorting/selection_sort/index.html

@@ -4937,7 +4937,7 @@
 </details>
 <h2 id="1121">11.2.1 &nbsp; Характеристики алгоритма<a class="headerlink" href="#1121" title="Permanent link">&para;</a></h2>
 <ul>
-<li><strong>Временная сложность равна <span class="arithmatex">\(O(n^2)\)</span>, сортировка не является адаптивной</strong>: внешний цикл выполняется <span class="arithmatex">\(n - 1\)</span> раз. В первом раунде длина неотсортированного диапазона равна <span class="arithmatex">\(n\)</span> , а в последнем - <span class="arithmatex">\(2\)</span> , то есть отдельные раунды содержат <span class="arithmatex">\(n\)</span>, <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(3\)</span>, <span class="arithmatex">\(2\)</span> проходов внутреннего цикла, их сумма равна <span class="arithmatex">\(\frac{(n - 1)(n + 2)}{2}\)</span> .</li>
+<li><strong>Временная сложность равна <span class="arithmatex">\(O(n^2)\)</span>, сортировка не является адаптивной</strong>: внешний цикл выполняется <span class="arithmatex">\(n - 1\)</span> раз. Внутренний цикл выполняется <span class="arithmatex">\(n - 1\)</span> раз в первом раунде и <span class="arithmatex">\(1\)</span> раз в последнем. Таким образом, число итераций внутреннего цикла по раундам равно <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(n - 2\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(2\)</span>, <span class="arithmatex">\(1\)</span>, а их сумма равна <span class="arithmatex">\(\frac{n(n - 1)}{2}\)</span> .</li>
 <li><strong>Пространственная сложность равна <span class="arithmatex">\(O(1)\)</span>, сортировка выполняется на месте</strong>: указатели <span class="arithmatex">\(i\)</span> и <span class="arithmatex">\(j\)</span> используют константный объем дополнительной памяти.</li>
 <li><strong>Нестабильная сортировка</strong>: как показано на рисунке 11-3, элемент <code>nums[i]</code> может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.</li>
 </ul>

ru/chapter_sorting/sorting_algorithm/index.html

@@ -4680,7 +4680,7 @@
 <a id="__codelineno-0-16" name="__codelineno-0-16" href="#__codelineno-0-16"></a><span class="w">  </span><span class="o">(</span><span class="s1">&#39;E&#39;</span>,<span class="w"> </span><span class="m">23</span><span class="o">)</span>
 </code></pre></div>
 <p><strong>Адаптивность</strong>: <u>адаптивная сортировка</u> умеет использовать уже существующий порядок входных данных, чтобы сократить вычисления и добиться лучшей эффективности. Лучшая временная сложность адаптивных алгоритмов обычно лучше их средней временной сложности.</p>
-<p><strong>Основанность на сравнении</strong>: <u>сортировка на основе сравнений</u> использует операторы сравнения (<span class="arithmatex">\(&lt;\)</span>, <span class="arithmatex">\(=\)</span>, <span class="arithmatex">\(&gt;\)</span>), чтобы определить относительный порядок элементов и отсортировать массив. Ее теоретически лучшая временная сложность равна <span class="arithmatex">\(O(n \log n)\)</span> . А вот <u>сортировка без сравнений</u> не опирается на операторы сравнения, поэтому может достигать <span class="arithmatex">\(O(n)\)</span> , но универсальность у нее ниже.</p>
+<p><strong>Основанность на сравнении</strong>: <u>сортировка на основе сравнений</u> использует операторы сравнения (<span class="arithmatex">\(&lt;\)</span>, <span class="arithmatex">\(=\)</span>, <span class="arithmatex">\(&gt;\)</span>), чтобы определить относительный порядок элементов и отсортировать массив. Нижняя граница ее временной сложности в худшем случае равна <span class="arithmatex">\(\Omega(n \log n)\)</span> . А вот <u>сортировка без сравнений</u> не опирается на операторы сравнения, поэтому может достигать <span class="arithmatex">\(O(n)\)</span> , но универсальность у нее ниже.</p>
 <h2 id="1112">11.1.2 &nbsp; Идеальный алгоритм сортировки<a class="headerlink" href="#1112" title="Permanent link">&para;</a></h2>
 <p><strong>Быстрый, выполняющийся на месте, стабильный, адаптивный и универсальный</strong>. Очевидно, что на сегодняшний день не существует алгоритма сортировки, который одновременно обладал бы всеми этими свойствами. Поэтому при выборе алгоритма сортировки нужно исходить из конкретных особенностей данных и требований задачи.</p>
 <p>Далее мы последовательно изучим разные алгоритмы сортировки и на основании приведенных выше критериев разберем их преимущества и недостатки.</p>

ru/chapter_stack_and_queue/queue/index.html

@@ -4913,7 +4913,7 @@
 <a id="__codelineno-5-14" name="__codelineno-5-14" href="#__codelineno-5-14"></a>
 <a id="__codelineno-5-15" name="__codelineno-5-15" href="#__codelineno-5-15"></a><span class="cm">/* Извлечь элемент из очереди */</span>
 <a id="__codelineno-5-16" name="__codelineno-5-16" href="#__codelineno-5-16"></a><span class="c1">// Поскольку в основе лежит массив, removeFirst имеет сложность O(n)</span>
-<a id="__codelineno-5-17" name="__codelineno-5-17" href="#__codelineno-5-17"></a><span class="kd">let</span><span class="w"> </span><span class="nv">pool</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">queue</span><span class="p">.</span><span class="n">removeFirst</span><span class="p">()</span>
+<a id="__codelineno-5-17" name="__codelineno-5-17" href="#__codelineno-5-17"></a><span class="kd">let</span><span class="w"> </span><span class="nv">pop</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">queue</span><span class="p">.</span><span class="n">removeFirst</span><span class="p">()</span>
 <a id="__codelineno-5-18" name="__codelineno-5-18" href="#__codelineno-5-18"></a>
 <a id="__codelineno-5-19" name="__codelineno-5-19" href="#__codelineno-5-19"></a><span class="cm">/* Получить длину очереди */</span>
 <a id="__codelineno-5-20" name="__codelineno-5-20" href="#__codelineno-5-20"></a><span class="kd">let</span><span class="w"> </span><span class="nv">size</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">queue</span><span class="p">.</span><span class="bp">count</span>

ru/chapter_tree/avl_tree/index.html

@@ -5129,9 +5129,9 @@
 <div class="tabbed-block">
 <div class="highlight"><pre><span></span><code><a id="__codelineno-11-1" name="__codelineno-11-1" href="#__codelineno-11-1"></a><span class="cm">/* Класс узла AVL-дерева */</span>
 <a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="kd">class</span><span class="w"> </span><span class="nc">TreeNode</span><span class="p">(</span><span class="kd">val</span><span class="w"> </span><span class="nv">_val</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">  </span><span class="c1">// Значение узла</span>
-<a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">height</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="m">0</span><span class="w">          </span><span class="c1">// Высота узла</span>
-<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">left</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">   </span><span class="c1">// Левый дочерний узел</span>
-<a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">right</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Правый дочерний узел</span>
+<a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">height</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="m">0</span><span class="w">          </span><span class="c1">// Высота узла</span>
+<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">left</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">   </span><span class="c1">// Левый дочерний узел</span>
+<a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">right</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Правый дочерний узел</span>
 <a id="__codelineno-11-6" name="__codelineno-11-6" href="#__codelineno-11-6"></a><span class="p">}</span>
 </code></pre></div>
 </div>

ru/chapter_tree/binary_tree/index.html

@@ -5010,8 +5010,8 @@
 <div class="tabbed-block">
 <div class="highlight"><pre><span></span><code><a id="__codelineno-11-1" name="__codelineno-11-1" href="#__codelineno-11-1"></a><span class="cm">/* Класс узла двоичного дерева */</span>
 <a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="kd">class</span><span class="w"> </span><span class="nc">TreeNode</span><span class="p">(</span><span class="kd">val</span><span class="w"> </span><span class="nv">_val</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">  </span><span class="c1">// Значение узла</span>
-<a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">left</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">   </span><span class="c1">// Ссылка на левого дочернего узла</span>
-<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="w">    </span><span class="kd">val</span><span class="w"> </span><span class="nv">right</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на правого дочернего узла</span>
+<a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">left</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">   </span><span class="c1">// Ссылка на левого дочернего узла</span>
+<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="w">    </span><span class="kd">var</span><span class="w"> </span><span class="nv">right</span><span class="p">:</span><span class="w"> </span><span class="n">TreeNode? </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="w">  </span><span class="c1">// Ссылка на правого дочернего узла</span>
 <a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="p">}</span>
 </code></pre></div>
 </div>

ru/javascripts/animation_player.js

@@ -251,4 +251,4 @@
     initAutoSlide();
   }
 })();
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/javascripts/katex.js

@@ -8,4 +8,4 @@ document$.subscribe(({ body }) => {
     ],
   });
 });
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/javascripts/mathjax.js

@@ -15,4 +15,4 @@ window.MathJax = {
 document$.subscribe(() => {
   MathJax.typesetPromise();
 });
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/javascripts/starfield.js

@@ -469,4 +469,4 @@
 
   return Starfield;
 });
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/stylesheets/animation_player.css

@@ -176,4 +176,4 @@
     font-size: 0.7rem;
   }
 }
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/stylesheets/extra.css

@@ -921,4 +921,4 @@ a:hover .device-on-hover {
     max-width: 100%;
   }
 }
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/stylesheets/giscus-dark.css

@@ -122,4 +122,4 @@ main .gsc-loading-image {
 .gsc-reply-content::-webkit-scrollbar-track {
   background: transparent;
 }
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */

ru/stylesheets/giscus-light.css

@@ -153,4 +153,4 @@ main {
 .gsc-reply-content::-webkit-scrollbar-track {
   background: transparent;
 }
-/*! update cache: 20260724072253 */
+/*! update cache: 20260817184839 */